﻿<!DOCTYPE html>
<!--[if IE]><![endif]-->
<html>
  
  <head>
    <meta charset="utf-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
    <title>Class FloatTensor
   </title>
    <meta name="viewport" content="width=device-width">
    <meta name="title" content="Class FloatTensor
   ">
    <meta name="generator" content="docfx 2.18.2.0">
    
    <link rel="shortcut icon" href="../../favicon.ico">
    <link rel="stylesheet" href="../../styles/docfx.vendor.css">
    <link rel="stylesheet" href="../../styles/docfx.css">
    <link rel="stylesheet" href="../../styles/main.css">
    <meta property="docfx:navrel" content="../../toc.html">
    <meta property="docfx:tocrel" content="../toc.html">
    
    
  </head>
  <body data-spy="scroll" data-target="#affix">
    <div id="wrapper">
      <header>
        
        <nav id="autocollapse" class="navbar navbar-inverse ng-scope" role="navigation">
          <div class="container">
            <div class="navbar-header">
              <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar">
                <span class="sr-only">Toggle navigation</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
              </button>
              
              <a class="navbar-brand" href="../../index.html">
                <img id="logo" class="svg" src="../../logo.svg" alt="">
              </a>
            </div>
            <div class="collapse navbar-collapse" id="navbar">
              <form class="navbar-form navbar-right" role="search" id="search">
                <div class="form-group">
                  <input type="text" class="form-control" id="search-query" placeholder="Search" autocomplete="off">
                </div>
              </form>
            </div>
          </div>
        </nav>
        
        <div class="subnav navbar navbar-default">
          <div class="container hide-when-search" id="breadcrumb">
            <ul class="breadcrumb">
              <li></li>
            </ul>
          </div>
        </div>
      </header>
      <div role="main" class="container body-content hide-when-search">
        
        <div class="sidenav hide-when-search">
          <a class="btn toc-toggle collapse" data-toggle="collapse" href="#sidetoggle" aria-expanded="false" aria-controls="sidetoggle">Show / Hide Table of Contents</a>
          <div class="sidetoggle collapse" id="sidetoggle">
            <div id="sidetoc"></div>
          </div>
        </div>
        <div class="article row grid-right">
          <div class="col-md-10">
            <article class="content wrap" id="_content" data-uid="TorchSharp.FloatTensor">
  
  
  <h1 id="TorchSharp_FloatTensor" data-uid="TorchSharp.FloatTensor">Class FloatTensor
  </h1>
  <div class="markdown level0 summary"><p>Tensor of type Float.</p>
</div>
  <div class="markdown level0 conceptual"></div>
  <div class="inheritance">
    <h5>Inheritance</h5>
    <div class="level0"><span class="xref">System.Object</span></div>
    <div class="level1"><span class="xref">FloatTensor</span></div>
  </div>
  <h6><strong>Namespace</strong>: <a class="xref" href="../TorchSharp.html">TorchSharp</a></h6>
  <h6><strong>Assembly</strong>: TorchSharp.dll</h6>
  <h5 id="TorchSharp_FloatTensor_syntax">Syntax</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public class FloatTensor : IDisposable</code></pre>
  </div>
  <h5 id="TorchSharp_FloatTensor_remarks"><strong>Remarks</strong></h5>
  <div class="markdown level0 remarks"><p>
                Use the default constructor to create an empty tensor, or invoke one of the
                constructors with one (1D), two (2D), three (3D), or four parameters (4D) to x
                create a tensor for the desired number of dimensions.
              </p></div>
  <h3 id="constructors">Constructors
  </h3>
  
  
  <a id="TorchSharp_FloatTensor__ctor_" data-uid="TorchSharp.FloatTensor.#ctor*"></a>
  <h4 id="TorchSharp_FloatTensor__ctor" data-uid="TorchSharp.FloatTensor.#ctor">FloatTensor()</h4>
  <div class="markdown level1 summary"><p>Creates an empty tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public FloatTensor ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_FloatTensor__ctor_" data-uid="TorchSharp.FloatTensor.#ctor*"></a>
  <h4 id="TorchSharp_FloatTensor__ctor_System_Int64_" data-uid="TorchSharp.FloatTensor.#ctor(System.Int64)">FloatTensor(Int64)</h4>
  <div class="markdown level1 summary"><p>Creates a 1D tensor of the specified size.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public FloatTensor (long size0);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size for the first dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor__ctor_" data-uid="TorchSharp.FloatTensor.#ctor*"></a>
  <h4 id="TorchSharp_FloatTensor__ctor_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.#ctor(System.Int64,System.Int64)">FloatTensor(Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Creates a 2D tensor of the specified size.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public FloatTensor (long size0, long size1);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size for the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size for the second dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor__ctor_" data-uid="TorchSharp.FloatTensor.#ctor*"></a>
  <h4 id="TorchSharp_FloatTensor__ctor_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.#ctor(System.Int64,System.Int64,System.Int64)">FloatTensor(Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Creates a 3D tensor of the specified size.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public FloatTensor (long size0, long size1, long size2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size for the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size for the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>Size for the third dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor__ctor_" data-uid="TorchSharp.FloatTensor.#ctor*"></a>
  <h4 id="TorchSharp_FloatTensor__ctor_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.#ctor(System.Int64,System.Int64,System.Int64,System.Int64)">FloatTensor(Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Creates a 4D tensor of the specified size.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public FloatTensor (long size0, long size1, long size2, long size3);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size for the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size for the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>Size for the third dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size3</span></td>
        <td><p>Size for the fourth dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h3 id="properties">Properties
  </h3>
  
  
  <a id="TorchSharp_FloatTensor_Data_" data-uid="TorchSharp.FloatTensor.Data*"></a>
  <h4 id="TorchSharp_FloatTensor_Data" data-uid="TorchSharp.FloatTensor.Data">Data</h4>
  <div class="markdown level1 summary"><p>Returns a pointer to the unmanaged data managed by this tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public float* Data { get; }</code></pre>
  </div>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span>*</td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Dimensions_" data-uid="TorchSharp.FloatTensor.Dimensions*"></a>
  <h4 id="TorchSharp_FloatTensor_Dimensions" data-uid="TorchSharp.FloatTensor.Dimensions">Dimensions</h4>
  <div class="markdown level1 summary"><p>Returns the number of dimensions for this tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public int Dimensions { get; }</code></pre>
  </div>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Item_" data-uid="TorchSharp.FloatTensor.Item*"></a>
  <h4 id="TorchSharp_FloatTensor_Item_System_Int64_" data-uid="TorchSharp.FloatTensor.Item(System.Int64)">Item(Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public float this[long x0] { get; set; }</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x0</span></td>
        <td><p>Index to access.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Item_" data-uid="TorchSharp.FloatTensor.Item*"></a>
  <h4 id="TorchSharp_FloatTensor_Item_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Item(System.Int64,System.Int64)">Item(Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public float this[long x0, long x1] { get; set; }</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x0</span></td>
        <td><p>Index in the first dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x1</span></td>
        <td><p>Index in the second dimension to access.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Item_" data-uid="TorchSharp.FloatTensor.Item*"></a>
  <h4 id="TorchSharp_FloatTensor_Item_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Item(System.Int64,System.Int64,System.Int64)">Item(Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public float this[long x0, long x1, long x2] { get; set; }</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x0</span></td>
        <td><p>Index in the first dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x1</span></td>
        <td><p>Index in the second dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x2</span></td>
        <td><p>Index in the third dimension to access.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Item_" data-uid="TorchSharp.FloatTensor.Item*"></a>
  <h4 id="TorchSharp_FloatTensor_Item_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Item(System.Int64,System.Int64,System.Int64,System.Int64)">Item(Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public float this[long x0, long x1, long x2, long x3] { get; set; }</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x0</span></td>
        <td><p>Index in the first dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x1</span></td>
        <td><p>Index in the second dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x2</span></td>
        <td><p>Index in the third dimension to access.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">x3</span></td>
        <td><p>Index in the fourth dimension to access.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Shape_" data-uid="TorchSharp.FloatTensor.Shape*"></a>
  <h4 id="TorchSharp_FloatTensor_Shape" data-uid="TorchSharp.FloatTensor.Shape">Shape</h4>
  <div class="markdown level1 summary"><p>Returns the tensor shape, this is an array whose size determines the number of dimensions on the tensor, and each element is the size of the dimension</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public long[] Shape { get; }</code></pre>
  </div>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span>[]</td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Shape_remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>An array of size 0 is used for constants, an array of size 1 is used
                for single-dimension arrays, where the dimension is the value of the
                first element.   And so on.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Storage_" data-uid="TorchSharp.FloatTensor.Storage*"></a>
  <h4 id="TorchSharp_FloatTensor_Storage" data-uid="TorchSharp.FloatTensor.Storage">Storage</h4>
  <div class="markdown level1 summary"><p>Returns the associated storage for this tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor.FloatStorage Storage { get; }</code></pre>
  </div>
  <h5 class="propertyValue">Property Value</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h3 id="methods">Methods
  </h3>
  
  
  <a id="TorchSharp_FloatTensor_Abs_" data-uid="TorchSharp.FloatTensor.Abs*"></a>
  <h4 id="TorchSharp_FloatTensor_Abs" data-uid="TorchSharp.FloatTensor.Abs">Abs()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Abs of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Abs ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Abs_" data-uid="TorchSharp.FloatTensor.Abs*"></a>
  <h4 id="TorchSharp_FloatTensor_Abs_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Abs(TorchSharp.FloatTensor)">Abs(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Abs of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Abs (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Acos_" data-uid="TorchSharp.FloatTensor.Acos*"></a>
  <h4 id="TorchSharp_FloatTensor_Acos" data-uid="TorchSharp.FloatTensor.Acos">Acos()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Acos of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Acos ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Acos_" data-uid="TorchSharp.FloatTensor.Acos*"></a>
  <h4 id="TorchSharp_FloatTensor_Acos_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Acos(TorchSharp.FloatTensor)">Acos(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Acos of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Acos (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Add_" data-uid="TorchSharp.FloatTensor.Add*"></a>
  <h4 id="TorchSharp_FloatTensor_Add_System_Single_" data-uid="TorchSharp.FloatTensor.Add(System.Single)">Add(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the Add operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Add (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Add_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Add(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Add_" data-uid="TorchSharp.FloatTensor.Add*"></a>
  <h4 id="TorchSharp_FloatTensor_Add_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Add(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">Add(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Add operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Add (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Add_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Add operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_AddBMM_" data-uid="TorchSharp.FloatTensor.AddBMM*"></a>
  <h4 id="TorchSharp_FloatTensor_AddBMM_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.AddBMM(System.Single,System.Single,TorchSharp.FloatTensor,TorchSharp.FloatTensor)">AddBMM(Single, Single, FloatTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddBMM of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor AddBMM (float beta, float alpha, TorchSharp.FloatTensor batch1, TorchSharp.FloatTensor batch2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for batch1xbatch2 (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">batch1</span></td>
        <td><p>the first batch of matrices to be multiplied</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">batch2</span></td>
        <td><p>the second batch of matrices to be multiplied</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>β mat+α (∑i=0bbatch1i@batch2i)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_AddBMM_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β mat+α (∑i=0bbatch1i@batch2i)</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_AddCDiv_" data-uid="TorchSharp.FloatTensor.AddCDiv*"></a>
  <h4 id="TorchSharp_FloatTensor_AddCDiv_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.AddCDiv(System.Single,TorchSharp.FloatTensor,TorchSharp.FloatTensor)">AddCDiv(Single, FloatTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddCDiv of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor AddCDiv (float value, TorchSharp.FloatTensor src1, TorchSharp.FloatTensor src2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_AddCMul_" data-uid="TorchSharp.FloatTensor.AddCMul*"></a>
  <h4 id="TorchSharp_FloatTensor_AddCMul_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.AddCMul(System.Single,TorchSharp.FloatTensor,TorchSharp.FloatTensor)">AddCMul(Single, FloatTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddCMul of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor AddCMul (float value, TorchSharp.FloatTensor src1, TorchSharp.FloatTensor src2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_AddMM_" data-uid="TorchSharp.FloatTensor.AddMM*"></a>
  <h4 id="TorchSharp_FloatTensor_AddMM_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.AddMM(System.Single,System.Single,TorchSharp.FloatTensor,TorchSharp.FloatTensor)">AddMM(Single, Single, FloatTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddMM of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor AddMM (float beta, float alpha, TorchSharp.FloatTensor mat1, TorchSharp.FloatTensor mat2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for mat1xmat2 (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">mat1</span></td>
        <td><p>First matrix to  be multiplied</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">mat2</span></td>
        <td><p>Second matrix to  be multiplied</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>β mat+α (mat1i@mat2i)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_AddMM_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β mat+α (mat1i@mat2i)</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_AddMV_" data-uid="TorchSharp.FloatTensor.AddMV*"></a>
  <h4 id="TorchSharp_FloatTensor_AddMV_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.AddMV(System.Single,System.Single,TorchSharp.FloatTensor,TorchSharp.FloatTensor)">AddMV(Single, Single, FloatTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddMV of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor AddMV (float beta, float alpha, TorchSharp.FloatTensor mat, TorchSharp.FloatTensor vec);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for matxvec (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">mat</span></td>
        <td><p>Matrix to be multiplied</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">vec</span></td>
        <td><p>Vector to be multiplied</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>β tensor+α (mat@vec)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_AddMV_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β tensor+α (mat@vec)</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_AddR_" data-uid="TorchSharp.FloatTensor.AddR*"></a>
  <h4 id="TorchSharp_FloatTensor_AddR_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.AddR(System.Single,System.Single,TorchSharp.FloatTensor,TorchSharp.FloatTensor)">AddR(Single, Single, FloatTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs AddR of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor AddR (float beta, float alpha, TorchSharp.FloatTensor vec1, TorchSharp.FloatTensor vec2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for vec1xvec2 (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">vec1</span></td>
        <td><p>the first vector of the outer product</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">vec2</span></td>
        <td><p>the second vector of the outer product</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>β mat+α (vec1⊗vec2)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_AddR_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β mat+α (vec1⊗vec2)</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_AddScaled_" data-uid="TorchSharp.FloatTensor.AddScaled*"></a>
  <h4 id="TorchSharp_FloatTensor_AddScaled_System_Single_System_Single_" data-uid="TorchSharp.FloatTensor.AddScaled(System.Single,System.Single)">AddScaled(Single, Single)</h4>
  <div class="markdown level1 summary"><p>Performs an AddScaled of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor AddScaled (float value1, float value2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_ARange_" data-uid="TorchSharp.FloatTensor.ARange*"></a>
  <h4 id="TorchSharp_FloatTensor_ARange_System_Double_System_Double_System_Double_" data-uid="TorchSharp.FloatTensor.ARange(System.Double,System.Double,System.Double)">ARange(Double, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Create a range spanning from xmin to xmax, with &#39;step&#39; between each value.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static TorchSharp.FloatTensor ARange (double xmin, double xmax, double step);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">xmin</span></td>
        <td><p>The lower bound of the range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">xmax</span></td>
        <td><p>The upper bound of the range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">step</span></td>
        <td><p>The value step.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Asin_" data-uid="TorchSharp.FloatTensor.Asin*"></a>
  <h4 id="TorchSharp_FloatTensor_Asin" data-uid="TorchSharp.FloatTensor.Asin">Asin()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Asin of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Asin ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Asin_" data-uid="TorchSharp.FloatTensor.Asin*"></a>
  <h4 id="TorchSharp_FloatTensor_Asin_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Asin(TorchSharp.FloatTensor)">Asin(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Asin of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Asin (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Atan_" data-uid="TorchSharp.FloatTensor.Atan*"></a>
  <h4 id="TorchSharp_FloatTensor_Atan" data-uid="TorchSharp.FloatTensor.Atan">Atan()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Atan of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Atan ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Atan_" data-uid="TorchSharp.FloatTensor.Atan*"></a>
  <h4 id="TorchSharp_FloatTensor_Atan_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Atan(TorchSharp.FloatTensor)">Atan(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Atan of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Atan (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Atan2_" data-uid="TorchSharp.FloatTensor.Atan2*"></a>
  <h4 id="TorchSharp_FloatTensor_Atan2" data-uid="TorchSharp.FloatTensor.Atan2">Atan2()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Atan2 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Atan2 ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Atan2_" data-uid="TorchSharp.FloatTensor.Atan2*"></a>
  <h4 id="TorchSharp_FloatTensor_Atan2_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Atan2(TorchSharp.FloatTensor)">Atan2(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Atan2 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Atan2 (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_BAddBMM_" data-uid="TorchSharp.FloatTensor.BAddBMM*"></a>
  <h4 id="TorchSharp_FloatTensor_BAddBMM_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.BAddBMM(System.Single,System.Single,TorchSharp.FloatTensor,TorchSharp.FloatTensor)">BAddBMM(Single, Single, FloatTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs BAddBMM of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor BAddBMM (float beta, float alpha, TorchSharp.FloatTensor batch1, TorchSharp.FloatTensor batch2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">beta</span></td>
        <td><p>Multiplier for this tensor (β).</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>Multiplier for batch1xbatch2 (α)</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">batch1</span></td>
        <td><p>the first batch of matrices to be multiplied</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">batch2</span></td>
        <td><p>the second batch of matrices to be multiplied</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>β mati+α (batch1i@batch2i)</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_BAddBMM_System_Single_System_Single_TorchSharp_FloatTensor_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>β mati+α (batch1i@batch2i)</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_BHistc_" data-uid="TorchSharp.FloatTensor.BHistc*"></a>
  <h4 id="TorchSharp_FloatTensor_BHistc_System_Int64_System_Single_System_Single_" data-uid="TorchSharp.FloatTensor.BHistc(System.Int64,System.Single,System.Single)">BHistc(Int64, Single, Single)</h4>
  <div class="markdown level1 summary"><p>Create a histogram of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor BHistc (long nbins, float minvalue, float maxvalue);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">nbins</span></td>
        <td><p>The number of bins in the output histogram.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">minvalue</span></td>
        <td><p>Only consider values equal to or greater than this.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">maxvalue</span></td>
        <td><p>Only consider values equal to or less than this.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_BitAnd_" data-uid="TorchSharp.FloatTensor.BitAnd*"></a>
  <h4 id="TorchSharp_FloatTensor_BitAnd_System_Single_" data-uid="TorchSharp.FloatTensor.BitAnd(System.Single)">BitAnd(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the BitAnd operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor BitAnd (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_BitAnd_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.BitAnd(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_BitAnd_" data-uid="TorchSharp.FloatTensor.BitAnd*"></a>
  <h4 id="TorchSharp_FloatTensor_BitAnd_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.BitAnd(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">BitAnd(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the BitAnd operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void BitAnd (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_BitAnd_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the BitAnd operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_CAdd_" data-uid="TorchSharp.FloatTensor.CAdd*"></a>
  <h4 id="TorchSharp_FloatTensor_CAdd_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CAdd(System.Single,TorchSharp.FloatTensor)">CAdd(Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the CAdd operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.
              where the result is t[idx] + value * src[idx]</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CAdd (float value, TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CappedRandom_" data-uid="TorchSharp.FloatTensor.CappedRandom*"></a>
  <h4 id="TorchSharp_FloatTensor_CappedRandom_TorchSharp_RandomGenerator_System_Int64_" data-uid="TorchSharp.FloatTensor.CappedRandom(TorchSharp.RandomGenerator,System.Int64)">CappedRandom(RandomGenerator, Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to max, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CappedRandom (TorchSharp.RandomGenerator source, long max);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">max</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Cauchy_" data-uid="TorchSharp.FloatTensor.Cauchy*"></a>
  <h4 id="TorchSharp_FloatTensor_Cauchy_TorchSharp_RandomGenerator_System_Double_System_Double_" data-uid="TorchSharp.FloatTensor.Cauchy(TorchSharp.RandomGenerator,System.Double,System.Double)">Cauchy(RandomGenerator, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a Cauchy-Lorentz distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Cauchy (TorchSharp.RandomGenerator source, double median, double sigma);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">median</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">sigma</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CBitAnd_" data-uid="TorchSharp.FloatTensor.CBitAnd*"></a>
  <h4 id="TorchSharp_FloatTensor_CBitAnd_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CBitAnd(TorchSharp.FloatTensor)">CBitAnd(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CBitAnd of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CBitAnd (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CBitOr_" data-uid="TorchSharp.FloatTensor.CBitOr*"></a>
  <h4 id="TorchSharp_FloatTensor_CBitOr_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CBitOr(TorchSharp.FloatTensor)">CBitOr(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CBitOr of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CBitOr (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CBitXor_" data-uid="TorchSharp.FloatTensor.CBitXor*"></a>
  <h4 id="TorchSharp_FloatTensor_CBitXor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CBitXor(TorchSharp.FloatTensor)">CBitXor(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CBitXor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CBitXor (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CDiv_" data-uid="TorchSharp.FloatTensor.CDiv*"></a>
  <h4 id="TorchSharp_FloatTensor_CDiv_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CDiv(TorchSharp.FloatTensor)">CDiv(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CDiv of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CDiv (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Ceil_" data-uid="TorchSharp.FloatTensor.Ceil*"></a>
  <h4 id="TorchSharp_FloatTensor_Ceil" data-uid="TorchSharp.FloatTensor.Ceil">Ceil()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Ceil of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Ceil ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Ceil_" data-uid="TorchSharp.FloatTensor.Ceil*"></a>
  <h4 id="TorchSharp_FloatTensor_Ceil_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Ceil(TorchSharp.FloatTensor)">Ceil(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Ceil of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Ceil (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CFMod_" data-uid="TorchSharp.FloatTensor.CFMod*"></a>
  <h4 id="TorchSharp_FloatTensor_CFMod_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CFMod(TorchSharp.FloatTensor)">CFMod(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CFMod of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CFMod (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_cinv_" data-uid="TorchSharp.FloatTensor.cinv*"></a>
  <h4 id="TorchSharp_FloatTensor_cinv" data-uid="TorchSharp.FloatTensor.cinv">cinv()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the cinv of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor cinv ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_cinv_" data-uid="TorchSharp.FloatTensor.cinv*"></a>
  <h4 id="TorchSharp_FloatTensor_cinv_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.cinv(TorchSharp.FloatTensor)">cinv(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the cinv of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor cinv (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Clamp_" data-uid="TorchSharp.FloatTensor.Clamp*"></a>
  <h4 id="TorchSharp_FloatTensor_Clamp_System_Single_" data-uid="TorchSharp.FloatTensor.Clamp(System.Single)">Clamp(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the Clamp operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Clamp (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Clamp_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Clamp(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Clamp_" data-uid="TorchSharp.FloatTensor.Clamp*"></a>
  <h4 id="TorchSharp_FloatTensor_Clamp_System_Single_System_Single_" data-uid="TorchSharp.FloatTensor.Clamp(System.Single,System.Single)">Clamp(Single, Single)</h4>
  <div class="markdown level1 summary"><p>Performs an Clamp of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Clamp (float value1, float value2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Clamp_" data-uid="TorchSharp.FloatTensor.Clamp*"></a>
  <h4 id="TorchSharp_FloatTensor_Clamp_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Clamp(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">Clamp(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Clamp operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Clamp (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Clamp_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Clamp operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_ClampedRandom_" data-uid="TorchSharp.FloatTensor.ClampedRandom*"></a>
  <h4 id="TorchSharp_FloatTensor_ClampedRandom_TorchSharp_RandomGenerator_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.ClampedRandom(TorchSharp.RandomGenerator,System.Int64,System.Int64)">ClampedRandom(RandomGenerator, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from min to max, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ClampedRandom (TorchSharp.RandomGenerator source, long min, long max);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">min</span></td>
        <td><p>The lower limit for the values to be generated</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">max</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Clone_" data-uid="TorchSharp.FloatTensor.Clone*"></a>
  <h4 id="TorchSharp_FloatTensor_Clone" data-uid="TorchSharp.FloatTensor.Clone">Clone()</h4>
  <div class="markdown level1 summary"><p>Returns a deep clone of the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Clone ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CLShift_" data-uid="TorchSharp.FloatTensor.CLShift*"></a>
  <h4 id="TorchSharp_FloatTensor_CLShift_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CLShift(TorchSharp.FloatTensor)">CLShift(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CLShift of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CLShift (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CMax_" data-uid="TorchSharp.FloatTensor.CMax*"></a>
  <h4 id="TorchSharp_FloatTensor_CMax_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CMax(TorchSharp.FloatTensor)">CMax(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CMax of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CMax (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CMaxValue_" data-uid="TorchSharp.FloatTensor.CMaxValue*"></a>
  <h4 id="TorchSharp_FloatTensor_CMaxValue_System_Single_" data-uid="TorchSharp.FloatTensor.CMaxValue(System.Single)">CMaxValue(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an CMaxValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CMaxValue (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CMin_" data-uid="TorchSharp.FloatTensor.CMin*"></a>
  <h4 id="TorchSharp_FloatTensor_CMin_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CMin(TorchSharp.FloatTensor)">CMin(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CMin of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CMin (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CMinValue_" data-uid="TorchSharp.FloatTensor.CMinValue*"></a>
  <h4 id="TorchSharp_FloatTensor_CMinValue_System_Single_" data-uid="TorchSharp.FloatTensor.CMinValue(System.Single)">CMinValue(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an CMinValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CMinValue (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CMul_" data-uid="TorchSharp.FloatTensor.CMul*"></a>
  <h4 id="TorchSharp_FloatTensor_CMul_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CMul(TorchSharp.FloatTensor)">CMul(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CMul of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CMul (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Concatenate_" data-uid="TorchSharp.FloatTensor.Concatenate*"></a>
  <h4 id="TorchSharp_FloatTensor_Concatenate_TorchSharp_FloatTensor_System_Int32_" data-uid="TorchSharp.FloatTensor.Concatenate(TorchSharp.FloatTensor,System.Int32)">Concatenate(FloatTensor, Int32)</h4>
  <div class="markdown level1 summary"><p>Concatenate tensors along the given dimesion.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Concatenate (TorchSharp.FloatTensor other, int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The second tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension along which to concatenate.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Copy_" data-uid="TorchSharp.FloatTensor.Copy*"></a>
  <h4 id="TorchSharp_FloatTensor_Copy_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Copy(TorchSharp.FloatTensor)">Copy(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Copy (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CopyByte_" data-uid="TorchSharp.FloatTensor.CopyByte*"></a>
  <h4 id="TorchSharp_FloatTensor_CopyByte_TorchSharp_ByteTensor_" data-uid="TorchSharp.FloatTensor.CopyByte(TorchSharp.ByteTensor)">CopyByte(ByteTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a byte tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyByte (TorchSharp.ByteTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CopyDouble_" data-uid="TorchSharp.FloatTensor.CopyDouble*"></a>
  <h4 id="TorchSharp_FloatTensor_CopyDouble_TorchSharp_DoubleTensor_" data-uid="TorchSharp.FloatTensor.CopyDouble(TorchSharp.DoubleTensor)">CopyDouble(DoubleTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a double tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyDouble (TorchSharp.DoubleTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.DoubleTensor.html">DoubleTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CopyFloat_" data-uid="TorchSharp.FloatTensor.CopyFloat*"></a>
  <h4 id="TorchSharp_FloatTensor_CopyFloat_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CopyFloat(TorchSharp.FloatTensor)">CopyFloat(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a float tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyFloat (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CopyInt_" data-uid="TorchSharp.FloatTensor.CopyInt*"></a>
  <h4 id="TorchSharp_FloatTensor_CopyInt_TorchSharp_IntTensor_" data-uid="TorchSharp.FloatTensor.CopyInt(TorchSharp.IntTensor)">CopyInt(IntTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a int tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyInt (TorchSharp.IntTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.IntTensor.html">IntTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CopyLong_" data-uid="TorchSharp.FloatTensor.CopyLong*"></a>
  <h4 id="TorchSharp_FloatTensor_CopyLong_TorchSharp_LongTensor_" data-uid="TorchSharp.FloatTensor.CopyLong(TorchSharp.LongTensor)">CopyLong(LongTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a long tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyLong (TorchSharp.LongTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CopyShort_" data-uid="TorchSharp.FloatTensor.CopyShort*"></a>
  <h4 id="TorchSharp_FloatTensor_CopyShort_TorchSharp_ShortTensor_" data-uid="TorchSharp.FloatTensor.CopyShort(TorchSharp.ShortTensor)">CopyShort(ShortTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of a short tensor into the original tensor. 
              The shape of the tensors must exactly match or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void CopyShort (TorchSharp.ShortTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ShortTensor.html">ShortTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Cos_" data-uid="TorchSharp.FloatTensor.Cos*"></a>
  <h4 id="TorchSharp_FloatTensor_Cos" data-uid="TorchSharp.FloatTensor.Cos">Cos()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Cos of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Cos ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Cos_" data-uid="TorchSharp.FloatTensor.Cos*"></a>
  <h4 id="TorchSharp_FloatTensor_Cos_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Cos(TorchSharp.FloatTensor)">Cos(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Cos of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Cos (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Cosh_" data-uid="TorchSharp.FloatTensor.Cosh*"></a>
  <h4 id="TorchSharp_FloatTensor_Cosh" data-uid="TorchSharp.FloatTensor.Cosh">Cosh()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Cosh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Cosh ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Cosh_" data-uid="TorchSharp.FloatTensor.Cosh*"></a>
  <h4 id="TorchSharp_FloatTensor_Cosh_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Cosh(TorchSharp.FloatTensor)">Cosh(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Cosh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Cosh (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CPow_" data-uid="TorchSharp.FloatTensor.CPow*"></a>
  <h4 id="TorchSharp_FloatTensor_CPow_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CPow(TorchSharp.FloatTensor)">CPow(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CPow of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CPow (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CRemainder_" data-uid="TorchSharp.FloatTensor.CRemainder*"></a>
  <h4 id="TorchSharp_FloatTensor_CRemainder_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CRemainder(TorchSharp.FloatTensor)">CRemainder(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an CRemainder of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CRemainder (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CrossProduct_" data-uid="TorchSharp.FloatTensor.CrossProduct*"></a>
  <h4 id="TorchSharp_FloatTensor_CrossProduct_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CrossProduct(TorchSharp.FloatTensor)">CrossProduct(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Computes the cross product of two tensors.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CrossProduct (TorchSharp.FloatTensor other);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The right-hand-side tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CSub_" data-uid="TorchSharp.FloatTensor.CSub*"></a>
  <h4 id="TorchSharp_FloatTensor_CSub_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.CSub(System.Single,TorchSharp.FloatTensor)">CSub(Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the CSub operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.
              where the result is t[idx] + value * src[idx]</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CSub (float value, TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CumulativeProd_" data-uid="TorchSharp.FloatTensor.CumulativeProd*"></a>
  <h4 id="TorchSharp_FloatTensor_CumulativeProd_System_Int32_" data-uid="TorchSharp.FloatTensor.CumulativeProd(System.Int32)">CumulativeProd(Int32)</h4>
  <div class="markdown level1 summary"><p>Computes the cumulative product of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CumulativeProd (int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_CumulativeSum_" data-uid="TorchSharp.FloatTensor.CumulativeSum*"></a>
  <h4 id="TorchSharp_FloatTensor_CumulativeSum_System_Int32_" data-uid="TorchSharp.FloatTensor.CumulativeSum(System.Int32)">CumulativeSum(Int32)</h4>
  <div class="markdown level1 summary"><p>Computes the cumulative sum of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor CumulativeSum (int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Diagonal_" data-uid="TorchSharp.FloatTensor.Diagonal*"></a>
  <h4 id="TorchSharp_FloatTensor_Diagonal_System_Int32_" data-uid="TorchSharp.FloatTensor.Diagonal(System.Int32)">Diagonal(Int32)</h4>
  <div class="markdown level1 summary"><p>Gets the diagonal of the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Diagonal (int k);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Digamma_" data-uid="TorchSharp.FloatTensor.Digamma*"></a>
  <h4 id="TorchSharp_FloatTensor_Digamma" data-uid="TorchSharp.FloatTensor.Digamma">Digamma()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Digamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Digamma ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Digamma_" data-uid="TorchSharp.FloatTensor.Digamma*"></a>
  <h4 id="TorchSharp_FloatTensor_Digamma_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Digamma(TorchSharp.FloatTensor)">Digamma(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Digamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Digamma (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_DirichletGrad_" data-uid="TorchSharp.FloatTensor.DirichletGrad*"></a>
  <h4 id="TorchSharp_FloatTensor_DirichletGrad_TorchSharp_FloatTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.DirichletGrad(TorchSharp.FloatTensor,TorchSharp.FloatTensor)">DirichletGrad(FloatTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>DirichletGrad</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor DirichletGrad (TorchSharp.FloatTensor alpha, TorchSharp.FloatTensor total);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">alpha</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">total</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Dispose_" data-uid="TorchSharp.FloatTensor.Dispose*"></a>
  <h4 id="TorchSharp_FloatTensor_Dispose" data-uid="TorchSharp.FloatTensor.Dispose">Dispose()</h4>
  <div class="markdown level1 summary"><p>Releases the tensor and its associated data.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Dispose ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_FloatTensor_Dispose_" data-uid="TorchSharp.FloatTensor.Dispose*"></a>
  <h4 id="TorchSharp_FloatTensor_Dispose_System_Boolean_" data-uid="TorchSharp.FloatTensor.Dispose(System.Boolean)">Dispose(Boolean)</h4>
  <div class="markdown level1 summary"><p>Implements the .NET Dispose pattern.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">protected void Dispose (bool disposing);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">disposing</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Dist_" data-uid="TorchSharp.FloatTensor.Dist*"></a>
  <h4 id="TorchSharp_FloatTensor_Dist_TorchSharp_FloatTensor_System_Single_" data-uid="TorchSharp.FloatTensor.Dist(TorchSharp.FloatTensor,System.Single)">Dist(FloatTensor, Single)</h4>
  <div class="markdown level1 summary"><p>Compute the dist of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double Dist (TorchSharp.FloatTensor other, float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The other tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Div_" data-uid="TorchSharp.FloatTensor.Div*"></a>
  <h4 id="TorchSharp_FloatTensor_Div_System_Single_" data-uid="TorchSharp.FloatTensor.Div(System.Single)">Div(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the Div operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Div (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Div_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Div(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Div_" data-uid="TorchSharp.FloatTensor.Div*"></a>
  <h4 id="TorchSharp_FloatTensor_Div_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Div(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">Div(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Div operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Div (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Div_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Div operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Dot_" data-uid="TorchSharp.FloatTensor.Dot*"></a>
  <h4 id="TorchSharp_FloatTensor_Dot_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Dot(TorchSharp.FloatTensor)">Dot(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns the tensor product between this tensor and the provided one</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double Dot (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The dot product</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_EqTensor_" data-uid="TorchSharp.FloatTensor.EqTensor*"></a>
  <h4 id="TorchSharp_FloatTensor_EqTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.EqTensor(TorchSharp.FloatTensor)">EqTensor(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an EqTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor EqTensor (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_EqTensorT_" data-uid="TorchSharp.FloatTensor.EqTensorT*"></a>
  <h4 id="TorchSharp_FloatTensor_EqTensorT_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.EqTensorT(TorchSharp.FloatTensor)">EqTensorT(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an EqTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor EqTensorT (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Equal_" data-uid="TorchSharp.FloatTensor.Equal*"></a>
  <h4 id="TorchSharp_FloatTensor_Equal_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Equal(TorchSharp.FloatTensor)">Equal(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Compare the tensor with another for complete equality.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public bool Equal (TorchSharp.FloatTensor other);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_EqValue_" data-uid="TorchSharp.FloatTensor.EqValue*"></a>
  <h4 id="TorchSharp_FloatTensor_EqValue_System_Single_" data-uid="TorchSharp.FloatTensor.EqValue(System.Single)">EqValue(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an EqValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor EqValue (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_EqValueT_" data-uid="TorchSharp.FloatTensor.EqValueT*"></a>
  <h4 id="TorchSharp_FloatTensor_EqValueT_System_Single_" data-uid="TorchSharp.FloatTensor.EqValueT(System.Single)">EqValueT(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an EqValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor EqValueT (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Erf_" data-uid="TorchSharp.FloatTensor.Erf*"></a>
  <h4 id="TorchSharp_FloatTensor_Erf" data-uid="TorchSharp.FloatTensor.Erf">Erf()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erf of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Erf ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Erf_" data-uid="TorchSharp.FloatTensor.Erf*"></a>
  <h4 id="TorchSharp_FloatTensor_Erf_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Erf(TorchSharp.FloatTensor)">Erf(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erf of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Erf (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Erfc_" data-uid="TorchSharp.FloatTensor.Erfc*"></a>
  <h4 id="TorchSharp_FloatTensor_Erfc" data-uid="TorchSharp.FloatTensor.Erfc">Erfc()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erfc of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Erfc ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Erfc_" data-uid="TorchSharp.FloatTensor.Erfc*"></a>
  <h4 id="TorchSharp_FloatTensor_Erfc_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Erfc(TorchSharp.FloatTensor)">Erfc(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erfc of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Erfc (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Erfinv_" data-uid="TorchSharp.FloatTensor.Erfinv*"></a>
  <h4 id="TorchSharp_FloatTensor_Erfinv" data-uid="TorchSharp.FloatTensor.Erfinv">Erfinv()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erfinv of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Erfinv ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Erfinv_" data-uid="TorchSharp.FloatTensor.Erfinv*"></a>
  <h4 id="TorchSharp_FloatTensor_Erfinv_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Erfinv(TorchSharp.FloatTensor)">Erfinv(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Erfinv of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Erfinv (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Exp_" data-uid="TorchSharp.FloatTensor.Exp*"></a>
  <h4 id="TorchSharp_FloatTensor_Exp" data-uid="TorchSharp.FloatTensor.Exp">Exp()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Exp of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Exp ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Exp_" data-uid="TorchSharp.FloatTensor.Exp*"></a>
  <h4 id="TorchSharp_FloatTensor_Exp_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Exp(TorchSharp.FloatTensor)">Exp(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Exp of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Exp (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Expm1_" data-uid="TorchSharp.FloatTensor.Expm1*"></a>
  <h4 id="TorchSharp_FloatTensor_Expm1" data-uid="TorchSharp.FloatTensor.Expm1">Expm1()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Expm1 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Expm1 ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Expm1_" data-uid="TorchSharp.FloatTensor.Expm1*"></a>
  <h4 id="TorchSharp_FloatTensor_Expm1_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Expm1(TorchSharp.FloatTensor)">Expm1(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Expm1 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Expm1 (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Exponential_" data-uid="TorchSharp.FloatTensor.Exponential*"></a>
  <h4 id="TorchSharp_FloatTensor_Exponential_TorchSharp_RandomGenerator_System_Double_" data-uid="TorchSharp.FloatTensor.Exponential(TorchSharp.RandomGenerator,System.Double)">Exponential(RandomGenerator, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a exponential distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Exponential (TorchSharp.RandomGenerator source, double lambda);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">lambda</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Eye_" data-uid="TorchSharp.FloatTensor.Eye*"></a>
  <h4 id="TorchSharp_FloatTensor_Eye_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Eye(System.Int64,System.Int64)">Eye(Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Eye.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static TorchSharp.FloatTensor Eye (long m, long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">m</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Fill_" data-uid="TorchSharp.FloatTensor.Fill*"></a>
  <h4 id="TorchSharp_FloatTensor_Fill_System_Single_" data-uid="TorchSharp.FloatTensor.Fill(System.Single)">Fill(Single)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with the specified value</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Fill (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Finalize_" data-uid="TorchSharp.FloatTensor.Finalize*"></a>
  <h4 id="TorchSharp_FloatTensor_Finalize" data-uid="TorchSharp.FloatTensor.Finalize">Finalize()</h4>
  <div class="markdown level1 summary"><p>Finalizer for ~FloatTensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">~FloatTensor ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_FloatTensor_Floor_" data-uid="TorchSharp.FloatTensor.Floor*"></a>
  <h4 id="TorchSharp_FloatTensor_Floor" data-uid="TorchSharp.FloatTensor.Floor">Floor()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Floor of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Floor ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Floor_" data-uid="TorchSharp.FloatTensor.Floor*"></a>
  <h4 id="TorchSharp_FloatTensor_Floor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Floor(TorchSharp.FloatTensor)">Floor(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Floor of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Floor (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Fmod_" data-uid="TorchSharp.FloatTensor.Fmod*"></a>
  <h4 id="TorchSharp_FloatTensor_Fmod_System_Single_" data-uid="TorchSharp.FloatTensor.Fmod(System.Single)">Fmod(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the Fmod operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Fmod (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Fmod_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Fmod(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Fmod_" data-uid="TorchSharp.FloatTensor.Fmod*"></a>
  <h4 id="TorchSharp_FloatTensor_Fmod_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Fmod(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">Fmod(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Fmod operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Fmod (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Fmod_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Fmod operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Frac_" data-uid="TorchSharp.FloatTensor.Frac*"></a>
  <h4 id="TorchSharp_FloatTensor_Frac" data-uid="TorchSharp.FloatTensor.Frac">Frac()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Frac of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Frac ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Frac_" data-uid="TorchSharp.FloatTensor.Frac*"></a>
  <h4 id="TorchSharp_FloatTensor_Frac_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Frac(TorchSharp.FloatTensor)">Frac(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Frac of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Frac (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Gather_" data-uid="TorchSharp.FloatTensor.Gather*"></a>
  <h4 id="TorchSharp_FloatTensor_Gather_TorchSharp_FloatTensor_System_Int32_TorchSharp_LongTensor_" data-uid="TorchSharp.FloatTensor.Gather(TorchSharp.FloatTensor,System.Int32,TorchSharp.LongTensor)">Gather(FloatTensor, Int32, LongTensor)</h4>
  <div class="markdown level1 summary"><p>Gather</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Gather (TorchSharp.FloatTensor src, int dim, TorchSharp.LongTensor index);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Geometric_" data-uid="TorchSharp.FloatTensor.Geometric*"></a>
  <h4 id="TorchSharp_FloatTensor_Geometric_TorchSharp_RandomGenerator_System_Double_" data-uid="TorchSharp.FloatTensor.Geometric(TorchSharp.RandomGenerator,System.Double)">Geometric(RandomGenerator, Double)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to n, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Geometric (TorchSharp.RandomGenerator source, double p);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">p</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GeTensor_" data-uid="TorchSharp.FloatTensor.GeTensor*"></a>
  <h4 id="TorchSharp_FloatTensor_GeTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.GeTensor(TorchSharp.FloatTensor)">GeTensor(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an GeTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor GeTensor (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GeTensorT_" data-uid="TorchSharp.FloatTensor.GeTensorT*"></a>
  <h4 id="TorchSharp_FloatTensor_GeTensorT_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.GeTensorT(TorchSharp.FloatTensor)">GeTensorT(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an GeTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor GeTensorT (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GetTensorDimension_" data-uid="TorchSharp.FloatTensor.GetTensorDimension*"></a>
  <h4 id="TorchSharp_FloatTensor_GetTensorDimension_System_Int32_" data-uid="TorchSharp.FloatTensor.GetTensorDimension(System.Int32)">GetTensorDimension(Int32)</h4>
  <div class="markdown level1 summary"><p>Retrieves the size of the specified dimension in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public long GetTensorDimension (int dim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GetTensorStride_" data-uid="TorchSharp.FloatTensor.GetTensorStride*"></a>
  <h4 id="TorchSharp_FloatTensor_GetTensorStride_System_Int32_" data-uid="TorchSharp.FloatTensor.GetTensorStride(System.Int32)">GetTensorStride(Int32)</h4>
  <div class="markdown level1 summary"><p>Retrieves the stride of the specified dimension in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public long GetTensorStride (int dim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GeValue_" data-uid="TorchSharp.FloatTensor.GeValue*"></a>
  <h4 id="TorchSharp_FloatTensor_GeValue_System_Single_" data-uid="TorchSharp.FloatTensor.GeValue(System.Single)">GeValue(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an GeValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor GeValue (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GeValueT_" data-uid="TorchSharp.FloatTensor.GeValueT*"></a>
  <h4 id="TorchSharp_FloatTensor_GeValueT_System_Single_" data-uid="TorchSharp.FloatTensor.GeValueT(System.Single)">GeValueT(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an GeValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor GeValueT (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GtTensor_" data-uid="TorchSharp.FloatTensor.GtTensor*"></a>
  <h4 id="TorchSharp_FloatTensor_GtTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.GtTensor(TorchSharp.FloatTensor)">GtTensor(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an GtTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor GtTensor (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GtTensorT_" data-uid="TorchSharp.FloatTensor.GtTensorT*"></a>
  <h4 id="TorchSharp_FloatTensor_GtTensorT_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.GtTensorT(TorchSharp.FloatTensor)">GtTensorT(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an GtTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor GtTensorT (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GtValue_" data-uid="TorchSharp.FloatTensor.GtValue*"></a>
  <h4 id="TorchSharp_FloatTensor_GtValue_System_Single_" data-uid="TorchSharp.FloatTensor.GtValue(System.Single)">GtValue(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an GtValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor GtValue (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_GtValueT_" data-uid="TorchSharp.FloatTensor.GtValueT*"></a>
  <h4 id="TorchSharp_FloatTensor_GtValueT_System_Single_" data-uid="TorchSharp.FloatTensor.GtValueT(System.Single)">GtValueT(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an GtValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor GtValueT (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Histc_" data-uid="TorchSharp.FloatTensor.Histc*"></a>
  <h4 id="TorchSharp_FloatTensor_Histc_System_Int64_System_Single_System_Single_" data-uid="TorchSharp.FloatTensor.Histc(System.Int64,System.Single,System.Single)">Histc(Int64, Single, Single)</h4>
  <div class="markdown level1 summary"><p>Create a histogram of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Histc (long nbins, float minvalue, float maxvalue);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">nbins</span></td>
        <td><p>The number of bins in the output histogram.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">minvalue</span></td>
        <td><p>Only consider values equal to or greater than this.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">maxvalue</span></td>
        <td><p>Only consider values equal to or less than this.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_IndexAdd_" data-uid="TorchSharp.FloatTensor.IndexAdd*"></a>
  <h4 id="TorchSharp_FloatTensor_IndexAdd_System_Int32_TorchSharp_LongTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.IndexAdd(System.Int32,TorchSharp.LongTensor,TorchSharp.FloatTensor)">IndexAdd(Int32, LongTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Adds the elements of tensor into the original tensor by selecting the indices in the order 
              given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void IndexAdd (int dim, TorchSharp.LongTensor index, TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select for the add</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Entries to copy</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_IndexCopy_" data-uid="TorchSharp.FloatTensor.IndexCopy*"></a>
  <h4 id="TorchSharp_FloatTensor_IndexCopy_System_Int32_TorchSharp_LongTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.IndexCopy(System.Int32,TorchSharp.LongTensor,TorchSharp.FloatTensor)">IndexCopy(Int32, LongTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Copies the elements of tensor into the original tensor by selecting the indices in the order 
              given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void IndexCopy (int dim, TorchSharp.LongTensor index, TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select for the copy</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Entries to copy</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>Tensor to copy the data from.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_IndexFill_" data-uid="TorchSharp.FloatTensor.IndexFill*"></a>
  <h4 id="TorchSharp_FloatTensor_IndexFill_System_Int32_TorchSharp_LongTensor_System_Single_" data-uid="TorchSharp.FloatTensor.IndexFill(System.Int32,TorchSharp.LongTensor,System.Single)">IndexFill(Int32, LongTensor, Single)</h4>
  <div class="markdown level1 summary"><p>Uses the given value to overwrite the original tensor by selecting the indices in the order 
              given in index. The shape of tensor must exactly match the elements indexed or an error will be thrown.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void IndexFill (int dim, TorchSharp.LongTensor index, float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select for the fill</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Entries to copy</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The value to write.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_IndexSelect_" data-uid="TorchSharp.FloatTensor.IndexSelect*"></a>
  <h4 id="TorchSharp_FloatTensor_IndexSelect_System_Int32_TorchSharp_LongTensor_" data-uid="TorchSharp.FloatTensor.IndexSelect(System.Int32,TorchSharp.LongTensor)">IndexSelect(Int32, LongTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new Tensor which indexes the original Tensor along dimension dim
              using the entries in index.  The returned Tensor has the same number of dimensions as the 
              original Tensor. The returned Tensor does not use the same storage as the original Tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor IndexSelect (int dim, TorchSharp.LongTensor index);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Entries to extract</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_KthValue_" data-uid="TorchSharp.FloatTensor.KthValue*"></a>
  <h4 id="TorchSharp_FloatTensor_KthValue_System_Int64_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.KthValue(System.Int64,System.Int32,System.Boolean)">KthValue(Int64, Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the kth value of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.FloatTensor,TorchSharp.LongTensor&gt; KthValue (long k, int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>The value for &#39;k&#39; in &#39;kth&#39;.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the kth element of each dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LERP_" data-uid="TorchSharp.FloatTensor.LERP*"></a>
  <h4 id="TorchSharp_FloatTensor_LERP_TorchSharp_FloatTensor_System_Single_" data-uid="TorchSharp.FloatTensor.LERP(TorchSharp.FloatTensor,System.Single)">LERP(FloatTensor, Single)</h4>
  <div class="markdown level1 summary"><p>LERP</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor LERP (TorchSharp.FloatTensor other, float weight);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">other</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">weight</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LeTensor_" data-uid="TorchSharp.FloatTensor.LeTensor*"></a>
  <h4 id="TorchSharp_FloatTensor_LeTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.LeTensor(TorchSharp.FloatTensor)">LeTensor(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an LeTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor LeTensor (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LeTensorT_" data-uid="TorchSharp.FloatTensor.LeTensorT*"></a>
  <h4 id="TorchSharp_FloatTensor_LeTensorT_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.LeTensorT(TorchSharp.FloatTensor)">LeTensorT(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an LeTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor LeTensorT (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LeValue_" data-uid="TorchSharp.FloatTensor.LeValue*"></a>
  <h4 id="TorchSharp_FloatTensor_LeValue_System_Single_" data-uid="TorchSharp.FloatTensor.LeValue(System.Single)">LeValue(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an LeValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor LeValue (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LeValueT_" data-uid="TorchSharp.FloatTensor.LeValueT*"></a>
  <h4 id="TorchSharp_FloatTensor_LeValueT_System_Single_" data-uid="TorchSharp.FloatTensor.LeValueT(System.Single)">LeValueT(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an LeValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor LeValueT (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Lgamma_" data-uid="TorchSharp.FloatTensor.Lgamma*"></a>
  <h4 id="TorchSharp_FloatTensor_Lgamma" data-uid="TorchSharp.FloatTensor.Lgamma">Lgamma()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Lgamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Lgamma ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Lgamma_" data-uid="TorchSharp.FloatTensor.Lgamma*"></a>
  <h4 id="TorchSharp_FloatTensor_Lgamma_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Lgamma(TorchSharp.FloatTensor)">Lgamma(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Lgamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Lgamma (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Linspace_" data-uid="TorchSharp.FloatTensor.Linspace*"></a>
  <h4 id="TorchSharp_FloatTensor_Linspace_System_Single_System_Single_System_Int64_" data-uid="TorchSharp.FloatTensor.Linspace(System.Single,System.Single,System.Int64)">Linspace(Single, Single, Int64)</h4>
  <div class="markdown level1 summary"><p>Performs Linspace of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Linspace (float a, float b, long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">a</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">b</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Log_" data-uid="TorchSharp.FloatTensor.Log*"></a>
  <h4 id="TorchSharp_FloatTensor_Log" data-uid="TorchSharp.FloatTensor.Log">Log()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Log ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Log_" data-uid="TorchSharp.FloatTensor.Log*"></a>
  <h4 id="TorchSharp_FloatTensor_Log_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Log(TorchSharp.FloatTensor)">Log(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Log (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Log10_" data-uid="TorchSharp.FloatTensor.Log10*"></a>
  <h4 id="TorchSharp_FloatTensor_Log10" data-uid="TorchSharp.FloatTensor.Log10">Log10()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log10 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Log10 ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Log10_" data-uid="TorchSharp.FloatTensor.Log10*"></a>
  <h4 id="TorchSharp_FloatTensor_Log10_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Log10(TorchSharp.FloatTensor)">Log10(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log10 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Log10 (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Log1p_" data-uid="TorchSharp.FloatTensor.Log1p*"></a>
  <h4 id="TorchSharp_FloatTensor_Log1p" data-uid="TorchSharp.FloatTensor.Log1p">Log1p()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log1p of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Log1p ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Log1p_" data-uid="TorchSharp.FloatTensor.Log1p*"></a>
  <h4 id="TorchSharp_FloatTensor_Log1p_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Log1p(TorchSharp.FloatTensor)">Log1p(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log1p of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Log1p (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Log2_" data-uid="TorchSharp.FloatTensor.Log2*"></a>
  <h4 id="TorchSharp_FloatTensor_Log2" data-uid="TorchSharp.FloatTensor.Log2">Log2()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log2 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Log2 ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Log2_" data-uid="TorchSharp.FloatTensor.Log2*"></a>
  <h4 id="TorchSharp_FloatTensor_Log2_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Log2(TorchSharp.FloatTensor)">Log2(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Log2 of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Log2 (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LogNormal_" data-uid="TorchSharp.FloatTensor.LogNormal*"></a>
  <h4 id="TorchSharp_FloatTensor_LogNormal_TorchSharp_RandomGenerator_System_Double_System_Double_" data-uid="TorchSharp.FloatTensor.LogNormal(TorchSharp.RandomGenerator,System.Double,System.Double)">LogNormal(RandomGenerator, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a log-normal distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void LogNormal (TorchSharp.RandomGenerator source, double mean, double stdv);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">mean</span></td>
        <td><p>The mean of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">stdv</span></td>
        <td><p>The standard deviation of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Logspace_" data-uid="TorchSharp.FloatTensor.Logspace*"></a>
  <h4 id="TorchSharp_FloatTensor_Logspace_System_Single_System_Single_System_Int64_" data-uid="TorchSharp.FloatTensor.Logspace(System.Single,System.Single,System.Int64)">Logspace(Single, Single, Int64)</h4>
  <div class="markdown level1 summary"><p>Performs Logspace of the tensor with the provided 
              <see paramref="src1"></see> and <see paramref="src1"></see> tensors and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Logspace (float a, float b, long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">a</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">b</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LShift_" data-uid="TorchSharp.FloatTensor.LShift*"></a>
  <h4 id="TorchSharp_FloatTensor_LShift_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.LShift(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">LShift(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the LShift operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void LShift (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_LShift_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the LShift operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_LShift_" data-uid="TorchSharp.FloatTensor.LShift*"></a>
  <h4 id="TorchSharp_FloatTensor_LShift_System_Single_" data-uid="TorchSharp.FloatTensor.LShift(System.Single)">LShift(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the LShift operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor LShift (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_LShift_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.LShift(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_LtTensor_" data-uid="TorchSharp.FloatTensor.LtTensor*"></a>
  <h4 id="TorchSharp_FloatTensor_LtTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.LtTensor(TorchSharp.FloatTensor)">LtTensor(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an LtTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor LtTensor (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LtTensorT_" data-uid="TorchSharp.FloatTensor.LtTensorT*"></a>
  <h4 id="TorchSharp_FloatTensor_LtTensorT_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.LtTensorT(TorchSharp.FloatTensor)">LtTensorT(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an LtTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor LtTensorT (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LtValue_" data-uid="TorchSharp.FloatTensor.LtValue*"></a>
  <h4 id="TorchSharp_FloatTensor_LtValue_System_Single_" data-uid="TorchSharp.FloatTensor.LtValue(System.Single)">LtValue(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an LtValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor LtValue (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_LtValueT_" data-uid="TorchSharp.FloatTensor.LtValueT*"></a>
  <h4 id="TorchSharp_FloatTensor_LtValueT_System_Single_" data-uid="TorchSharp.FloatTensor.LtValueT(System.Single)">LtValueT(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an LtValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor LtValueT (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_MaskedCopy_" data-uid="TorchSharp.FloatTensor.MaskedCopy*"></a>
  <h4 id="TorchSharp_FloatTensor_MaskedCopy_TorchSharp_ByteTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.MaskedCopy(TorchSharp.ByteTensor,TorchSharp.FloatTensor)">MaskedCopy(ByteTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Copies elements from the source tensor to the locations indicated by the mask.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void MaskedCopy (TorchSharp.ByteTensor mask, TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><span class="parametername">mask</span></td>
        <td><p>A byte tensor with values 0 or 1 indicating the locations where in the destination the value should be filled.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_MaskedCopy_TorchSharp_ByteTensor_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>There must be at least as many elements in the source tensor as there are 1s in the mask.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_MaskedFill_" data-uid="TorchSharp.FloatTensor.MaskedFill*"></a>
  <h4 id="TorchSharp_FloatTensor_MaskedFill_TorchSharp_ByteTensor_System_Single_" data-uid="TorchSharp.FloatTensor.MaskedFill(TorchSharp.ByteTensor,System.Single)">MaskedFill(ByteTensor, Single)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with the specified value at the locations indicated by the mask.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void MaskedFill (TorchSharp.ByteTensor mask, float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><span class="parametername">mask</span></td>
        <td><p>A byte tensor with values 0 or 1 indicating the locations where the value should be filled.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The value to write at the indicated locations.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_MaskedSelect_" data-uid="TorchSharp.FloatTensor.MaskedSelect*"></a>
  <h4 id="TorchSharp_FloatTensor_MaskedSelect_TorchSharp_ByteTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.MaskedSelect(TorchSharp.ByteTensor,TorchSharp.FloatTensor)">MaskedSelect(ByteTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Copies elements from the source tensor at the locations indicated by the mask.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void MaskedSelect (TorchSharp.ByteTensor mask, TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><span class="parametername">mask</span></td>
        <td><p>A byte tensor with values 0 or 1 indicating the locations where in the source the value should be fetched.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_MaskedSelect_TorchSharp_ByteTensor_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>There will be as many elements in the tensor as there are 1s in the mask.
             There must be at least as many elements in the source tensor as there are 1s in the mask.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Match_" data-uid="TorchSharp.FloatTensor.Match*"></a>
  <h4 id="TorchSharp_FloatTensor_Match_TorchSharp_FloatTensor_System_Single_" data-uid="TorchSharp.FloatTensor.Match(TorchSharp.FloatTensor,System.Single)">Match(FloatTensor, Single)</h4>
  <div class="markdown level1 summary"><p>Match</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Match (TorchSharp.FloatTensor m2, float gain);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">m2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">gain</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Max_" data-uid="TorchSharp.FloatTensor.Max*"></a>
  <h4 id="TorchSharp_FloatTensor_Max_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.Max(System.Int32,System.Boolean)">Max(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the max of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.FloatTensor,TorchSharp.LongTensor&gt; Max (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the resulting elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_MaxAll_" data-uid="TorchSharp.FloatTensor.MaxAll*"></a>
  <h4 id="TorchSharp_FloatTensor_MaxAll" data-uid="TorchSharp.FloatTensor.MaxAll">MaxAll()</h4>
  <div class="markdown level1 summary"><p>Returns the maximum value of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public float MaxAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><p>The maximum value of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Mean_" data-uid="TorchSharp.FloatTensor.Mean*"></a>
  <h4 id="TorchSharp_FloatTensor_Mean_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.Mean(System.Int32,System.Boolean)">Mean(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the mean of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Mean (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_MeanAll_" data-uid="TorchSharp.FloatTensor.MeanAll*"></a>
  <h4 id="TorchSharp_FloatTensor_MeanAll" data-uid="TorchSharp.FloatTensor.MeanAll">MeanAll()</h4>
  <div class="markdown level1 summary"><p>Compute the mean of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double MeanAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The mean of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Median_" data-uid="TorchSharp.FloatTensor.Median*"></a>
  <h4 id="TorchSharp_FloatTensor_Median_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.Median(System.Int32,System.Boolean)">Median(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the median of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.FloatTensor,TorchSharp.LongTensor&gt; Median (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the resulting elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_MedianAll_" data-uid="TorchSharp.FloatTensor.MedianAll*"></a>
  <h4 id="TorchSharp_FloatTensor_MedianAll" data-uid="TorchSharp.FloatTensor.MedianAll">MedianAll()</h4>
  <div class="markdown level1 summary"><p>Returns the median of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public float MedianAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><p>The median of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Min_" data-uid="TorchSharp.FloatTensor.Min*"></a>
  <h4 id="TorchSharp_FloatTensor_Min_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.Min(System.Int32,System.Boolean)">Min(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the min of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.FloatTensor,TorchSharp.LongTensor&gt; Min (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the resulting elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_MinAll_" data-uid="TorchSharp.FloatTensor.MinAll*"></a>
  <h4 id="TorchSharp_FloatTensor_MinAll" data-uid="TorchSharp.FloatTensor.MinAll">MinAll()</h4>
  <div class="markdown level1 summary"><p>Returns the minimum value of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public float MinAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><p>The minimum value of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Mode_" data-uid="TorchSharp.FloatTensor.Mode*"></a>
  <h4 id="TorchSharp_FloatTensor_Mode_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.Mode(System.Int32,System.Boolean)">Mode(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the mode of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.FloatTensor,TorchSharp.LongTensor&gt; Mode (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the resulting elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Mul_" data-uid="TorchSharp.FloatTensor.Mul*"></a>
  <h4 id="TorchSharp_FloatTensor_Mul_System_Single_" data-uid="TorchSharp.FloatTensor.Mul(System.Single)">Mul(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the Mul operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Mul (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Mul_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Mul(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Mul_" data-uid="TorchSharp.FloatTensor.Mul*"></a>
  <h4 id="TorchSharp_FloatTensor_Mul_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Mul(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">Mul(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Mul operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Mul (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Mul_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Mul operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Multinomial_" data-uid="TorchSharp.FloatTensor.Multinomial*"></a>
  <h4 id="TorchSharp_FloatTensor_Multinomial_TorchSharp_RandomGenerator_TorchSharp_FloatTensor_System_Int32_System_Int32_" data-uid="TorchSharp.FloatTensor.Multinomial(TorchSharp.RandomGenerator,TorchSharp.FloatTensor,System.Int32,System.Int32)">Multinomial(RandomGenerator, FloatTensor, Int32, Int32)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a multinomial distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Multinomial (TorchSharp.RandomGenerator source, TorchSharp.FloatTensor prob_dist, int n_sample, int with_replacement);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">prob_dist</span></td>
        <td><p>The probability for each bucket.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">n_sample</span></td>
        <td><p>The number of samples to generate.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">with_replacement</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Narrow_" data-uid="TorchSharp.FloatTensor.Narrow*"></a>
  <h4 id="TorchSharp_FloatTensor_Narrow_System_Int32_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Narrow(System.Int32,System.Int64,System.Int64)">Narrow(Int32, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Returns a new Tensor which is a narrowed version of the current one: the dimension dim is narrowed from firstIndexto firstIndex+size-1.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Narrow (int dim, long firstIndex, long size);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>The dimension to narrow</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">firstIndex</span></td>
        <td><p>Initial index to narrow</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size</span></td>
        <td><p>Number of elements</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_neg_" data-uid="TorchSharp.FloatTensor.neg*"></a>
  <h4 id="TorchSharp_FloatTensor_neg" data-uid="TorchSharp.FloatTensor.neg">neg()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the neg of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor neg ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_neg_" data-uid="TorchSharp.FloatTensor.neg*"></a>
  <h4 id="TorchSharp_FloatTensor_neg_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.neg(TorchSharp.FloatTensor)">neg(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the neg of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor neg (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NeTensor_" data-uid="TorchSharp.FloatTensor.NeTensor*"></a>
  <h4 id="TorchSharp_FloatTensor_NeTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.NeTensor(TorchSharp.FloatTensor)">NeTensor(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an NeTensor of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor NeTensor (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NeTensorT_" data-uid="TorchSharp.FloatTensor.NeTensorT*"></a>
  <h4 id="TorchSharp_FloatTensor_NeTensorT_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.NeTensorT(TorchSharp.FloatTensor)">NeTensorT(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs an NeTensorT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor NeTensorT (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NeValue_" data-uid="TorchSharp.FloatTensor.NeValue*"></a>
  <h4 id="TorchSharp_FloatTensor_NeValue_System_Single_" data-uid="TorchSharp.FloatTensor.NeValue(System.Single)">NeValue(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an NeValue of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.ByteTensor NeValue (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.ByteTensor.html">ByteTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NeValueT_" data-uid="TorchSharp.FloatTensor.NeValueT*"></a>
  <h4 id="TorchSharp_FloatTensor_NeValueT_System_Single_" data-uid="TorchSharp.FloatTensor.NeValueT(System.Single)">NeValueT(Single)</h4>
  <div class="markdown level1 summary"><p>Performs an NeValueT of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor NeValueT (float src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">src</span></td>
        <td><p>The right-hand-side operand.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NewWithStorage1d_" data-uid="TorchSharp.FloatTensor.NewWithStorage1d*"></a>
  <h4 id="TorchSharp_FloatTensor_NewWithStorage1d_System_IntPtr_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.NewWithStorage1d(System.IntPtr,System.Int64,System.Int64)">NewWithStorage1d(IntPtr, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor NewWithStorage1d (IntPtr offset, long size, long stride);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.IntPtr</span></td>
        <td><span class="parametername">offset</span></td>
        <td><p>Offset within the input storage the storage of the new tensor will start from.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size</span></td>
        <td><p>Size of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride</span></td>
        <td><p>Stride of the first dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NewWithStorage2d_" data-uid="TorchSharp.FloatTensor.NewWithStorage2d*"></a>
  <h4 id="TorchSharp_FloatTensor_NewWithStorage2d_System_IntPtr_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.NewWithStorage2d(System.IntPtr,System.Int64,System.Int64,System.Int64,System.Int64)">NewWithStorage2d(IntPtr, Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor NewWithStorage2d (IntPtr offset, long size0, long stride0, long size1, long stride1);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.IntPtr</span></td>
        <td><span class="parametername">offset</span></td>
        <td><p>Offset within the input storage the storage of the new tensor will start from.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride0</span></td>
        <td><p>Stride of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride1</span></td>
        <td><p>Stride of the second dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NewWithStorage3d_" data-uid="TorchSharp.FloatTensor.NewWithStorage3d*"></a>
  <h4 id="TorchSharp_FloatTensor_NewWithStorage3d_System_IntPtr_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.NewWithStorage3d(System.IntPtr,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64)">NewWithStorage3d(IntPtr, Int64, Int64, Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor NewWithStorage3d (IntPtr offset, long size0, long stride0, long size1, long stride1, long size2, long stride2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.IntPtr</span></td>
        <td><span class="parametername">offset</span></td>
        <td><p>Offset within the input storage the storage of the new tensor will start from.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride0</span></td>
        <td><p>Stride of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride1</span></td>
        <td><p>Stride of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>Size of the third dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride2</span></td>
        <td><p>Stride of the third dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NewWithStorage4d_" data-uid="TorchSharp.FloatTensor.NewWithStorage4d*"></a>
  <h4 id="TorchSharp_FloatTensor_NewWithStorage4d_System_IntPtr_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.NewWithStorage4d(System.IntPtr,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64,System.Int64)">NewWithStorage4d(IntPtr, Int64, Int64, Int64, Int64, Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Access to element at the specified position in the tensor</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor NewWithStorage4d (IntPtr offset, long size0, long stride0, long size1, long stride1, long size2, long stride2, long size3, long stride3);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.IntPtr</span></td>
        <td><span class="parametername">offset</span></td>
        <td><p>Offset within the input storage the storage of the new tensor will start from.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>Size of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride0</span></td>
        <td><p>Stride of the first dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>Size of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride1</span></td>
        <td><p>Stride of the second dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>Size of the third dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride2</span></td>
        <td><p>Stride of the third dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size3</span></td>
        <td><p>Size of the fourth dimension.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">stride3</span></td>
        <td><p>Stride of the fourth dimension.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NonZero_" data-uid="TorchSharp.FloatTensor.NonZero*"></a>
  <h4 id="TorchSharp_FloatTensor_NonZero" data-uid="TorchSharp.FloatTensor.NonZero">NonZero()</h4>
  <div class="markdown level1 summary"><p>Finds the indices of all non-zero elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.LongTensor NonZero ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Norm_" data-uid="TorchSharp.FloatTensor.Norm*"></a>
  <h4 id="TorchSharp_FloatTensor_Norm_System_Single_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.Norm(System.Single,System.Int32,System.Boolean)">Norm(Single, Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the norm of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Norm (float value, int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Normal_" data-uid="TorchSharp.FloatTensor.Normal*"></a>
  <h4 id="TorchSharp_FloatTensor_Normal_TorchSharp_RandomGenerator_System_Double_System_Double_" data-uid="TorchSharp.FloatTensor.Normal(TorchSharp.RandomGenerator,System.Double,System.Double)">Normal(RandomGenerator, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a normal distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Normal (TorchSharp.RandomGenerator source, double mean, double stdv);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">mean</span></td>
        <td><p>The mean of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">stdv</span></td>
        <td><p>The standard deviation of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NormAll_" data-uid="TorchSharp.FloatTensor.NormAll*"></a>
  <h4 id="TorchSharp_FloatTensor_NormAll_System_Single_" data-uid="TorchSharp.FloatTensor.NormAll(System.Single)">NormAll(Single)</h4>
  <div class="markdown level1 summary"><p>Compute the norm of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double NormAll (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NormalMeans_" data-uid="TorchSharp.FloatTensor.NormalMeans*"></a>
  <h4 id="TorchSharp_FloatTensor_NormalMeans_TorchSharp_RandomGenerator_TorchSharp_FloatTensor_System_Double_" data-uid="TorchSharp.FloatTensor.NormalMeans(TorchSharp.RandomGenerator,TorchSharp.FloatTensor,System.Double)">NormalMeans(RandomGenerator, FloatTensor, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a normal distribution. This version uses multiple means.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void NormalMeans (TorchSharp.RandomGenerator source, TorchSharp.FloatTensor means, double stdv);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">means</span></td>
        <td><p>The means of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">stdv</span></td>
        <td><p>The standard deviation of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NormalMeansStdvs_" data-uid="TorchSharp.FloatTensor.NormalMeansStdvs*"></a>
  <h4 id="TorchSharp_FloatTensor_NormalMeansStdvs_TorchSharp_RandomGenerator_TorchSharp_FloatTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.NormalMeansStdvs(TorchSharp.RandomGenerator,TorchSharp.FloatTensor,TorchSharp.FloatTensor)">NormalMeansStdvs(RandomGenerator, FloatTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a normal distribution. This version uses multiple means and standard deviations.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void NormalMeansStdvs (TorchSharp.RandomGenerator source, TorchSharp.FloatTensor means, TorchSharp.FloatTensor stdvs);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">means</span></td>
        <td><p>The means of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">stdvs</span></td>
        <td><p>The standards deviation of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NormalStdvs_" data-uid="TorchSharp.FloatTensor.NormalStdvs*"></a>
  <h4 id="TorchSharp_FloatTensor_NormalStdvs_TorchSharp_RandomGenerator_System_Double_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.NormalStdvs(TorchSharp.RandomGenerator,System.Double,TorchSharp.FloatTensor)">NormalStdvs(RandomGenerator, Double, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a normal distribution. This version uses multiple standard deviations.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void NormalStdvs (TorchSharp.RandomGenerator source, double mean, TorchSharp.FloatTensor stdvs);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">mean</span></td>
        <td><p>The mean of the distribution.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">stdvs</span></td>
        <td><p>The standard deviations of the distribution.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_NumElements_" data-uid="TorchSharp.FloatTensor.NumElements*"></a>
  <h4 id="TorchSharp_FloatTensor_NumElements" data-uid="TorchSharp.FloatTensor.NumElements">NumElements()</h4>
  <div class="markdown level1 summary"><p>Get the number of elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public long NumElements ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_OnesLike_" data-uid="TorchSharp.FloatTensor.OnesLike*"></a>
  <h4 id="TorchSharp_FloatTensor_OnesLike" data-uid="TorchSharp.FloatTensor.OnesLike">OnesLike()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the OnesLike of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor OnesLike ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Polygamma_" data-uid="TorchSharp.FloatTensor.Polygamma*"></a>
  <h4 id="TorchSharp_FloatTensor_Polygamma" data-uid="TorchSharp.FloatTensor.Polygamma">Polygamma()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Polygamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Polygamma ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Polygamma_" data-uid="TorchSharp.FloatTensor.Polygamma*"></a>
  <h4 id="TorchSharp_FloatTensor_Polygamma_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Polygamma(TorchSharp.FloatTensor)">Polygamma(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Polygamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Polygamma (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Pow_" data-uid="TorchSharp.FloatTensor.Pow*"></a>
  <h4 id="TorchSharp_FloatTensor_Pow_System_Single_" data-uid="TorchSharp.FloatTensor.Pow(System.Single)">Pow(Single)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with <see paramref="this"></see> raised to the power of <see paramref="y"></see>.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Pow (float y);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">y</span></td>
        <td><p>The exponent.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Prod_" data-uid="TorchSharp.FloatTensor.Prod*"></a>
  <h4 id="TorchSharp_FloatTensor_Prod_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.Prod(System.Int32,System.Boolean)">Prod(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the product of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Prod (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_ProdAll_" data-uid="TorchSharp.FloatTensor.ProdAll*"></a>
  <h4 id="TorchSharp_FloatTensor_ProdAll" data-uid="TorchSharp.FloatTensor.ProdAll">ProdAll()</h4>
  <div class="markdown level1 summary"><p>Returns the product of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double ProdAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The product of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Put_" data-uid="TorchSharp.FloatTensor.Put*"></a>
  <h4 id="TorchSharp_FloatTensor_Put_TorchSharp_LongTensor_TorchSharp_FloatTensor_System_Boolean_" data-uid="TorchSharp.FloatTensor.Put(TorchSharp.LongTensor,TorchSharp.FloatTensor,System.Boolean)">Put(LongTensor, FloatTensor, Boolean)</h4>
  <div class="markdown level1 summary"><p>Put</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Put (TorchSharp.LongTensor index, TorchSharp.FloatTensor src, bool accumulate);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">accumulate</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Random_" data-uid="TorchSharp.FloatTensor.Random*"></a>
  <h4 id="TorchSharp_FloatTensor_Random_TorchSharp_RandomGenerator_" data-uid="TorchSharp.FloatTensor.Random(TorchSharp.RandomGenerator)">Random(RandomGenerator)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Random (TorchSharp.RandomGenerator source);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Random_" data-uid="TorchSharp.FloatTensor.Random*"></a>
  <h4 id="TorchSharp_FloatTensor_Random_TorchSharp_RandomGenerator_System_Int64_" data-uid="TorchSharp.FloatTensor.Random(TorchSharp.RandomGenerator,System.Int64)">Random(RandomGenerator, Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to n, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Random (TorchSharp.RandomGenerator source, long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Random_" data-uid="TorchSharp.FloatTensor.Random*"></a>
  <h4 id="TorchSharp_FloatTensor_Random_System_Int64_" data-uid="TorchSharp.FloatTensor.Random(System.Int64)">Random(Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to n, using a newly initialized Random number geneator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Random (long n);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">n</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_RandPerm_" data-uid="TorchSharp.FloatTensor.RandPerm*"></a>
  <h4 id="TorchSharp_FloatTensor_RandPerm_TorchSharp_RandomGenerator_System_Int64_" data-uid="TorchSharp.FloatTensor.RandPerm(TorchSharp.RandomGenerator,System.Int64)">RandPerm(RandomGenerator, Int64)</h4>
  <div class="markdown level1 summary"><p>Populates the tensor with random values from 0 to n, using the provided random source generator.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void RandPerm (TorchSharp.RandomGenerator source, long max);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">max</span></td>
        <td><p>The upper limit for the values to be generated</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Range_" data-uid="TorchSharp.FloatTensor.Range*"></a>
  <h4 id="TorchSharp_FloatTensor_Range_System_Double_System_Double_System_Double_" data-uid="TorchSharp.FloatTensor.Range(System.Double,System.Double,System.Double)">Range(Double, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Create a range spanning from xmin to xmax, with &#39;step&#39; between each value.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static TorchSharp.FloatTensor Range (double xmin, double xmax, double step);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">xmin</span></td>
        <td><p>The lower bound of the range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">xmax</span></td>
        <td><p>The upper bound of the range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">step</span></td>
        <td><p>The value step.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Remainder_" data-uid="TorchSharp.FloatTensor.Remainder*"></a>
  <h4 id="TorchSharp_FloatTensor_Remainder_System_Single_" data-uid="TorchSharp.FloatTensor.Remainder(System.Single)">Remainder(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the Remainder operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Remainder (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Remainder_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Remainder(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Remainder_" data-uid="TorchSharp.FloatTensor.Remainder*"></a>
  <h4 id="TorchSharp_FloatTensor_Remainder_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Remainder(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">Remainder(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Remainder operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Remainder (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Remainder_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Remainder operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Renorm_" data-uid="TorchSharp.FloatTensor.Renorm*"></a>
  <h4 id="TorchSharp_FloatTensor_Renorm_System_Single_System_Int32_System_Single_" data-uid="TorchSharp.FloatTensor.Renorm(System.Single,System.Int32,System.Single)">Renorm(Single, Int32, Single)</h4>
  <div class="markdown level1 summary"><p>Compute the renorm of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Renorm (float value, int dimension, float maxnorm);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">maxnorm</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Resize1d_" data-uid="TorchSharp.FloatTensor.Resize1d*"></a>
  <h4 id="TorchSharp_FloatTensor_Resize1d_System_Int64_" data-uid="TorchSharp.FloatTensor.Resize1d(System.Int64)">Resize1d(Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be one dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize1d (long size);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Resize2d_" data-uid="TorchSharp.FloatTensor.Resize2d*"></a>
  <h4 id="TorchSharp_FloatTensor_Resize2d_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Resize2d(System.Int64,System.Int64)">Resize2d(Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be two dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize2d (long size0, long size1);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>The desired new size for the second dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Resize3d_" data-uid="TorchSharp.FloatTensor.Resize3d*"></a>
  <h4 id="TorchSharp_FloatTensor_Resize3d_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Resize3d(System.Int64,System.Int64,System.Int64)">Resize3d(Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be three dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize3d (long size0, long size1, long size2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>The desired new size for the second dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>The desired new size for the third dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Resize4d_" data-uid="TorchSharp.FloatTensor.Resize4d*"></a>
  <h4 id="TorchSharp_FloatTensor_Resize4d_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Resize4d(System.Int64,System.Int64,System.Int64,System.Int64)">Resize4d(Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be four dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize4d (long size0, long size1, long size2, long size3);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>The desired new size for the second dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>The desired new size for the third dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size3</span></td>
        <td><p>The desired new size for the fourth dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Resize5d_" data-uid="TorchSharp.FloatTensor.Resize5d*"></a>
  <h4 id="TorchSharp_FloatTensor_Resize5d_System_Int64_System_Int64_System_Int64_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Resize5d(System.Int64,System.Int64,System.Int64,System.Int64,System.Int64)">Resize5d(Int64, Int64, Int64, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to be five dimensional with the specified size, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Resize5d (long size0, long size1, long size2, long size3, long size4);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size0</span></td>
        <td><p>The desired new size for the first dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size1</span></td>
        <td><p>The desired new size for the second dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size2</span></td>
        <td><p>The desired new size for the third dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size3</span></td>
        <td><p>The desired new size for the fourth dimension of the tensor.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size4</span></td>
        <td><p>The desired new size for the fifth dimension of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_ResizeAs_" data-uid="TorchSharp.FloatTensor.ResizeAs*"></a>
  <h4 id="TorchSharp_FloatTensor_ResizeAs_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.ResizeAs(TorchSharp.FloatTensor)">ResizeAs(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Resizes the tensor to match the dimensions of the specified src tensor, the contents of the tensor after this are undetermined.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ResizeAs (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor whose shape will be mirrored by this tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Round_" data-uid="TorchSharp.FloatTensor.Round*"></a>
  <h4 id="TorchSharp_FloatTensor_Round" data-uid="TorchSharp.FloatTensor.Round">Round()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Round of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Round ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Round_" data-uid="TorchSharp.FloatTensor.Round*"></a>
  <h4 id="TorchSharp_FloatTensor_Round_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Round(TorchSharp.FloatTensor)">Round(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Round of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Round (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_RShift_" data-uid="TorchSharp.FloatTensor.RShift*"></a>
  <h4 id="TorchSharp_FloatTensor_RShift_System_Single_" data-uid="TorchSharp.FloatTensor.RShift(System.Single)">RShift(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the RShift operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor RShift (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_RShift_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.RShift(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_RShift_" data-uid="TorchSharp.FloatTensor.RShift*"></a>
  <h4 id="TorchSharp_FloatTensor_RShift_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.RShift(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">RShift(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the RShift operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void RShift (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_RShift_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the RShift operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Rsqrt_" data-uid="TorchSharp.FloatTensor.Rsqrt*"></a>
  <h4 id="TorchSharp_FloatTensor_Rsqrt_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Rsqrt(TorchSharp.FloatTensor)">Rsqrt(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Rsqrt of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Rsqrt (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Rsqrt_" data-uid="TorchSharp.FloatTensor.Rsqrt*"></a>
  <h4 id="TorchSharp_FloatTensor_Rsqrt" data-uid="TorchSharp.FloatTensor.Rsqrt">Rsqrt()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Rsqrt of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Rsqrt ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Scatter_" data-uid="TorchSharp.FloatTensor.Scatter*"></a>
  <h4 id="TorchSharp_FloatTensor_Scatter_System_Int32_TorchSharp_LongTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Scatter(System.Int32,TorchSharp.LongTensor,TorchSharp.FloatTensor)">Scatter(Int32, LongTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Scatter</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Scatter (int dim, TorchSharp.LongTensor index, TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_ScatterAdd_" data-uid="TorchSharp.FloatTensor.ScatterAdd*"></a>
  <h4 id="TorchSharp_FloatTensor_ScatterAdd_System_Int32_TorchSharp_LongTensor_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.ScatterAdd(System.Int32,TorchSharp.LongTensor,TorchSharp.FloatTensor)">ScatterAdd(Int32, LongTensor, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>ScatterAdd</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ScatterAdd (int dim, TorchSharp.LongTensor index, TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_ScatterFill_" data-uid="TorchSharp.FloatTensor.ScatterFill*"></a>
  <h4 id="TorchSharp_FloatTensor_ScatterFill_System_Int32_TorchSharp_LongTensor_System_Single_" data-uid="TorchSharp.FloatTensor.ScatterFill(System.Int32,TorchSharp.LongTensor,System.Single)">ScatterFill(Int32, LongTensor, Single)</h4>
  <div class="markdown level1 summary"><p>ScatterAdd</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ScatterFill (int dim, TorchSharp.LongTensor index, float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Select_" data-uid="TorchSharp.FloatTensor.Select*"></a>
  <h4 id="TorchSharp_FloatTensor_Select_System_Int32_System_Int64_" data-uid="TorchSharp.FloatTensor.Select(System.Int32,System.Int64)">Select(Int32, Int64)</h4>
  <div class="markdown level1 summary"><p>Returns a new Tensor which is a tensor slice at the given index in the dimension dim.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Select (int dim, long slideIndex);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>Dimension to select</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">slideIndex</span></td>
        <td><p>Beginning of the tensor slice</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Select_System_Int32_System_Int64__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>The returned tensor has one less dimension: the dimension dim is removed. As a result, it is not possible to select() on a 1D tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Set_" data-uid="TorchSharp.FloatTensor.Set*"></a>
  <h4 id="TorchSharp_FloatTensor_Set_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Set(TorchSharp.FloatTensor)">Set(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>The tensor will use the same storage as the provided source, so any changes to that tensor are visible on this one.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Set (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor which contains the data..</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sigmoid_" data-uid="TorchSharp.FloatTensor.Sigmoid*"></a>
  <h4 id="TorchSharp_FloatTensor_Sigmoid" data-uid="TorchSharp.FloatTensor.Sigmoid">Sigmoid()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sigmoid of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sigmoid ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sigmoid_" data-uid="TorchSharp.FloatTensor.Sigmoid*"></a>
  <h4 id="TorchSharp_FloatTensor_Sigmoid_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Sigmoid(TorchSharp.FloatTensor)">Sigmoid(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sigmoid of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sigmoid (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sign_" data-uid="TorchSharp.FloatTensor.Sign*"></a>
  <h4 id="TorchSharp_FloatTensor_Sign" data-uid="TorchSharp.FloatTensor.Sign">Sign()</h4>
  <div class="markdown level1 summary"><p>Computes the sign of the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sign ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sin_" data-uid="TorchSharp.FloatTensor.Sin*"></a>
  <h4 id="TorchSharp_FloatTensor_Sin" data-uid="TorchSharp.FloatTensor.Sin">Sin()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sin of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sin ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sin_" data-uid="TorchSharp.FloatTensor.Sin*"></a>
  <h4 id="TorchSharp_FloatTensor_Sin_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Sin(TorchSharp.FloatTensor)">Sin(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sin of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sin (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sinh_" data-uid="TorchSharp.FloatTensor.Sinh*"></a>
  <h4 id="TorchSharp_FloatTensor_Sinh" data-uid="TorchSharp.FloatTensor.Sinh">Sinh()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sinh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sinh ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sinh_" data-uid="TorchSharp.FloatTensor.Sinh*"></a>
  <h4 id="TorchSharp_FloatTensor_Sinh_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Sinh(TorchSharp.FloatTensor)">Sinh(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sinh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sinh (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sort_" data-uid="TorchSharp.FloatTensor.Sort*"></a>
  <h4 id="TorchSharp_FloatTensor_Sort_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.Sort(System.Int32,System.Boolean)">Sort(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Sorts the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.FloatTensor,TorchSharp.LongTensor&gt; Sort (int dimension, bool descending);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to sort along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">descending</span></td>
        <td><p>0 if ascending, 1 if descending.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the sorted elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sqrt_" data-uid="TorchSharp.FloatTensor.Sqrt*"></a>
  <h4 id="TorchSharp_FloatTensor_Sqrt_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Sqrt(TorchSharp.FloatTensor)">Sqrt(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sqrt of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sqrt (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sqrt_" data-uid="TorchSharp.FloatTensor.Sqrt*"></a>
  <h4 id="TorchSharp_FloatTensor_Sqrt" data-uid="TorchSharp.FloatTensor.Sqrt">Sqrt()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Sqrt of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sqrt ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Squeeze_" data-uid="TorchSharp.FloatTensor.Squeeze*"></a>
  <h4 id="TorchSharp_FloatTensor_Squeeze" data-uid="TorchSharp.FloatTensor.Squeeze">Squeeze()</h4>
  <div class="markdown level1 summary"><p>Squeeze the tensor, i.e. remove all 1-sized dimensions.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Squeeze ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_FloatTensor_Squeeze1d_" data-uid="TorchSharp.FloatTensor.Squeeze1d*"></a>
  <h4 id="TorchSharp_FloatTensor_Squeeze1d_TorchSharp_FloatTensor_System_Int32_" data-uid="TorchSharp.FloatTensor.Squeeze1d(TorchSharp.FloatTensor,System.Int32)">Squeeze1d(FloatTensor, Int32)</h4>
  <div class="markdown level1 summary"><p>Squeeze the tensor, by removing the specified dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Squeeze1d (TorchSharp.FloatTensor src, int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor which contains the data.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to remove.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Std_" data-uid="TorchSharp.FloatTensor.Std*"></a>
  <h4 id="TorchSharp_FloatTensor_Std_System_Int32_System_Boolean_System_Boolean_" data-uid="TorchSharp.FloatTensor.Std(System.Int32,System.Boolean,System.Boolean)">Std(Int32, Boolean, Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the standard deviation of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Std (int dimension, bool biased, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">biased</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_StdAll_" data-uid="TorchSharp.FloatTensor.StdAll*"></a>
  <h4 id="TorchSharp_FloatTensor_StdAll_System_Boolean_" data-uid="TorchSharp.FloatTensor.StdAll(System.Boolean)">StdAll(Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the standard deviation of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double StdAll (bool biased);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">biased</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sub_" data-uid="TorchSharp.FloatTensor.Sub*"></a>
  <h4 id="TorchSharp_FloatTensor_Sub_System_Single_" data-uid="TorchSharp.FloatTensor.Sub(System.Single)">Sub(Single)</h4>
  <div class="markdown level1 summary"><p>Performs the Sub operation on each element of the tensor with the
              <see paramref="value"></see> and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sub (float value);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Sub_System_Single__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>If you want to avoid the allocation of a new tensor, you can use the 
              alternative method <span class="xref">PytorchSharp.Sub(PytorchSharp.FloatTensor, Float, PytorchSharp.Float)</span>.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_Sub_" data-uid="TorchSharp.FloatTensor.Sub*"></a>
  <h4 id="TorchSharp_FloatTensor_Sub_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Sub(TorchSharp.FloatTensor,System.Single,TorchSharp.FloatTensor)">Sub(FloatTensor, Single, FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Performs the Sub operation on each element of the source with the
              provided scalar.   The result tensor specified as the last parameters
              is resized to match the source.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public static void Sub (TorchSharp.FloatTensor source, float value, TorchSharp.FloatTensor result);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>Source tensor on which the operation will take place.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value</span></td>
        <td><p>The scalar value that the operation uses.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">result</span></td>
        <td><p>The tensor where the result will be placed</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 id="TorchSharp_FloatTensor_Sub_TorchSharp_FloatTensor_System_Single_TorchSharp_FloatTensor__remarks">Remarks</h5>
  <div class="markdown level1 remarks"><p>For each element in the <see paramref="source"></see> performs the Sub operation
               with <see paramref="value"></see>.   The result is stored in the <see paramref="result"></see>
               tensor.</p>
</div>
  
  
  <a id="TorchSharp_FloatTensor_SubScaled_" data-uid="TorchSharp.FloatTensor.SubScaled*"></a>
  <h4 id="TorchSharp_FloatTensor_SubScaled_System_Single_System_Single_" data-uid="TorchSharp.FloatTensor.SubScaled(System.Single,System.Single)">SubScaled(Single, Single)</h4>
  <div class="markdown level1 summary"><p>Performs an SubScaled of the tensor with the provided 
              <see paramref="src"></see> tensor and returns a new tensor with the result.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor SubScaled (float value1, float value2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value1</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">value2</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Sum_" data-uid="TorchSharp.FloatTensor.Sum*"></a>
  <h4 id="TorchSharp_FloatTensor_Sum_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.Sum(System.Int32,System.Boolean)">Sum(Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Computes the sum of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Sum (int dimension, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_SumAll_" data-uid="TorchSharp.FloatTensor.SumAll*"></a>
  <h4 id="TorchSharp_FloatTensor_SumAll" data-uid="TorchSharp.FloatTensor.SumAll">SumAll()</h4>
  <div class="markdown level1 summary"><p>Returns the sum of the elements in the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double SumAll ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>The sum of the tensor.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Take_" data-uid="TorchSharp.FloatTensor.Take*"></a>
  <h4 id="TorchSharp_FloatTensor_Take_TorchSharp_FloatTensor_TorchSharp_LongTensor_" data-uid="TorchSharp.FloatTensor.Take(TorchSharp.FloatTensor,TorchSharp.LongTensor)">Take(FloatTensor, LongTensor)</h4>
  <div class="markdown level1 summary"><p>Take</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Take (TorchSharp.FloatTensor src, TorchSharp.LongTensor index);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a></td>
        <td><span class="parametername">index</span></td>
        <td><p>Indices of entries to copy.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Tan_" data-uid="TorchSharp.FloatTensor.Tan*"></a>
  <h4 id="TorchSharp_FloatTensor_Tan" data-uid="TorchSharp.FloatTensor.Tan">Tan()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Tan of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Tan ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Tan_" data-uid="TorchSharp.FloatTensor.Tan*"></a>
  <h4 id="TorchSharp_FloatTensor_Tan_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Tan(TorchSharp.FloatTensor)">Tan(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Tan of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Tan (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Tanh_" data-uid="TorchSharp.FloatTensor.Tanh*"></a>
  <h4 id="TorchSharp_FloatTensor_Tanh" data-uid="TorchSharp.FloatTensor.Tanh">Tanh()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Tanh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Tanh ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Tanh_" data-uid="TorchSharp.FloatTensor.Tanh*"></a>
  <h4 id="TorchSharp_FloatTensor_Tanh_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Tanh(TorchSharp.FloatTensor)">Tanh(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Tanh of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Tanh (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_TopK_" data-uid="TorchSharp.FloatTensor.TopK*"></a>
  <h4 id="TorchSharp_FloatTensor_TopK_System_Int64_System_Int32_System_Int32_System_Boolean_" data-uid="TorchSharp.FloatTensor.TopK(System.Int64,System.Int32,System.Int32,System.Boolean)">TopK(Int64, Int32, Int32, Boolean)</h4>
  <div class="markdown level1 summary"><p>Finds the top k of all the elements of the tensor along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public Tuple&lt;TorchSharp.FloatTensor,TorchSharp.LongTensor&gt; TopK (long k, int dim, int dir, bool sorted);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>The number of elements to fetch.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>The dimension along which to sort and find k elements.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dir</span></td>
        <td><p>0 if ascending, 1 if descending.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">sorted</span></td>
        <td><p>1 if the result should be sorted, 0 if they should keep their original order.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Tuple</span>&lt;<a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a>,<a class="xref" href="TorchSharp.LongTensor.html">LongTensor</a>&gt;</td>
        <td><p>A tuple containing the values and indices of the top &#39;k&#39; elements.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_ToString_" data-uid="TorchSharp.FloatTensor.ToString*"></a>
  <h4 id="TorchSharp_FloatTensor_ToString" data-uid="TorchSharp.FloatTensor.ToString">ToString()</h4>
  <div class="markdown level1 summary"><p>Get a string representation of the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public override string ToString ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.String</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_TPow_" data-uid="TorchSharp.FloatTensor.TPow*"></a>
  <h4 id="TorchSharp_FloatTensor_TPow_System_Single_" data-uid="TorchSharp.FloatTensor.TPow(System.Single)">TPow(Single)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with <see paramref="x"></see> raised to the power of <see paramref="this"></see>.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor TPow (float x);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Single</span></td>
        <td><span class="parametername">x</span></td>
        <td><p>The base.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Trace_" data-uid="TorchSharp.FloatTensor.Trace*"></a>
  <h4 id="TorchSharp_FloatTensor_Trace" data-uid="TorchSharp.FloatTensor.Trace">Trace()</h4>
  <div class="markdown level1 summary"><p>Computes the trace of the tensor.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double Trace ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Transpose_" data-uid="TorchSharp.FloatTensor.Transpose*"></a>
  <h4 id="TorchSharp_FloatTensor_Transpose_System_Int32_System_Int32_" data-uid="TorchSharp.FloatTensor.Transpose(System.Int32,System.Int32)">Transpose(Int32, Int32)</h4>
  <div class="markdown level1 summary"><p>Returns a tensor where dimensions dim1 and dim2 have been swapped.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Transpose (int dim1, int dim2);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim1</span></td>
        <td><p>First dimension</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim2</span></td>
        <td><p>Second dimension</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Trigamma_" data-uid="TorchSharp.FloatTensor.Trigamma*"></a>
  <h4 id="TorchSharp_FloatTensor_Trigamma" data-uid="TorchSharp.FloatTensor.Trigamma">Trigamma()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Trigamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Trigamma ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Trigamma_" data-uid="TorchSharp.FloatTensor.Trigamma*"></a>
  <h4 id="TorchSharp_FloatTensor_Trigamma_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Trigamma(TorchSharp.FloatTensor)">Trigamma(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Trigamma of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Trigamma (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_TriL_" data-uid="TorchSharp.FloatTensor.TriL*"></a>
  <h4 id="TorchSharp_FloatTensor_TriL_System_Int64_" data-uid="TorchSharp.FloatTensor.TriL(System.Int64)">TriL(Int64)</h4>
  <div class="markdown level1 summary"><p>Lower triangle.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor TriL (long k);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_TriU_" data-uid="TorchSharp.FloatTensor.TriU*"></a>
  <h4 id="TorchSharp_FloatTensor_TriU_System_Int64_" data-uid="TorchSharp.FloatTensor.TriU(System.Int64)">TriU(Int64)</h4>
  <div class="markdown level1 summary"><p>Upper triangle.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor TriU (long k);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">k</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Trunc_" data-uid="TorchSharp.FloatTensor.Trunc*"></a>
  <h4 id="TorchSharp_FloatTensor_Trunc" data-uid="TorchSharp.FloatTensor.Trunc">Trunc()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Trunc of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Trunc ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Trunc_" data-uid="TorchSharp.FloatTensor.Trunc*"></a>
  <h4 id="TorchSharp_FloatTensor_Trunc_TorchSharp_FloatTensor_" data-uid="TorchSharp.FloatTensor.Trunc(TorchSharp.FloatTensor)">Trunc(FloatTensor)</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the Trunc of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Trunc (TorchSharp.FloatTensor src);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Unfold_" data-uid="TorchSharp.FloatTensor.Unfold*"></a>
  <h4 id="TorchSharp_FloatTensor_Unfold_System_Int32_System_Int64_System_Int64_" data-uid="TorchSharp.FloatTensor.Unfold(System.Int32,System.Int64,System.Int64)">Unfold(Int32, Int64, Int64)</h4>
  <div class="markdown level1 summary"><p>Returns a tensor which contains all slices of size size in the dimension dim. Step between two slices is given by step.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Unfold (int dim, long size, long step);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dim</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">size</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int64</span></td>
        <td><span class="parametername">step</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Uniform_" data-uid="TorchSharp.FloatTensor.Uniform*"></a>
  <h4 id="TorchSharp_FloatTensor_Uniform_TorchSharp_RandomGenerator_System_Double_System_Double_" data-uid="TorchSharp.FloatTensor.Uniform(TorchSharp.RandomGenerator,System.Double,System.Double)">Uniform(RandomGenerator, Double, Double)</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with values according to a Bernoulli distribution.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Uniform (TorchSharp.RandomGenerator source, double min, double max);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.RandomGenerator.html">RandomGenerator</a></td>
        <td><span class="parametername">source</span></td>
        <td><p>The random generator source</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">min</span></td>
        <td><p>The lower bound for the random number range.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><span class="parametername">max</span></td>
        <td><p>The upper bound for the random number range.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Unsqueeze1d_" data-uid="TorchSharp.FloatTensor.Unsqueeze1d*"></a>
  <h4 id="TorchSharp_FloatTensor_Unsqueeze1d_TorchSharp_FloatTensor_System_Int32_" data-uid="TorchSharp.FloatTensor.Unsqueeze1d(TorchSharp.FloatTensor,System.Int32)">Unsqueeze1d(FloatTensor, Int32)</h4>
  <div class="markdown level1 summary"><p>Unsqueeze the tensor, by inserting the specified dimension of size 1.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void Unsqueeze1d (TorchSharp.FloatTensor src, int dimension);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><span class="parametername">src</span></td>
        <td><p>The source tensor which contains the data.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to insert.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_Var_" data-uid="TorchSharp.FloatTensor.Var*"></a>
  <h4 id="TorchSharp_FloatTensor_Var_System_Int32_System_Boolean_System_Boolean_" data-uid="TorchSharp.FloatTensor.Var(System.Int32,System.Boolean,System.Boolean)">Var(Int32, Boolean, Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the variance of all tensor elements along the given dimension.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor Var (int dimension, bool biased, bool keepdim);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Int32</span></td>
        <td><span class="parametername">dimension</span></td>
        <td><p>The dimension to process along.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">biased</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">keepdim</span></td>
        <td><p>true if the reduction dimension should be kept, false otherwise.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_VarAll_" data-uid="TorchSharp.FloatTensor.VarAll*"></a>
  <h4 id="TorchSharp_FloatTensor_VarAll_System_Boolean_" data-uid="TorchSharp.FloatTensor.VarAll(System.Boolean)">VarAll(Boolean)</h4>
  <div class="markdown level1 summary"><p>Compute the variance of all tensor elements.</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public double VarAll (bool biased);</code></pre>
  </div>
  <h5 class="parameters">Parameters</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Name</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Boolean</span></td>
        <td><span class="parametername">biased</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><span class="xref">System.Double</span></td>
        <td><p>To be added.</p>
</td>
      </tr>
    </tbody>
  </table>
  
  
  <a id="TorchSharp_FloatTensor_ZeroFill_" data-uid="TorchSharp.FloatTensor.ZeroFill*"></a>
  <h4 id="TorchSharp_FloatTensor_ZeroFill" data-uid="TorchSharp.FloatTensor.ZeroFill">ZeroFill()</h4>
  <div class="markdown level1 summary"><p>Fills the tensor with zeros</p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public void ZeroFill ();</code></pre>
  </div>
  
  
  <a id="TorchSharp_FloatTensor_ZerosLike_" data-uid="TorchSharp.FloatTensor.ZerosLike*"></a>
  <h4 id="TorchSharp_FloatTensor_ZerosLike" data-uid="TorchSharp.FloatTensor.ZerosLike">ZerosLike()</h4>
  <div class="markdown level1 summary"><p>Returns a new tensor with the ZerosLike of the elements of <see paramref="src"></see></p>
</div>
  <div class="markdown level1 conceptual"></div>
  <h5 class="decalaration">Declaration</h5>
  <div class="codewrapper">
    <pre><code class="lang-csharp hljs">public TorchSharp.FloatTensor ZerosLike ();</code></pre>
  </div>
  <h5 class="returns">Returns</h5>
  <table class="table table-bordered table-striped table-condensed">
    <thead>
      <tr>
        <th>Type</th>
        <th>Description</th>
      </tr>
    </thead>
    <tbody>
      <tr>
        <td><a class="xref" href="TorchSharp.FloatTensor.html">FloatTensor</a></td>
        <td><p>This returns a new tensor with the same shape as the tensor this operates on.</p>
</td>
      </tr>
    </tbody>
  </table>
</article>
          </div>
          
          <div class="hidden-sm col-md-2" role="complementary">
            <div class="sideaffix">
              <div class="contribution">
                <ul class="nav">
                </ul>
              </div>
              <nav class="bs-docs-sidebar hidden-print hidden-xs hidden-sm affix" id="affix">
              <!-- <p><a class="back-to-top" href="#top">Back to top</a><p> -->
              </nav>
            </div>
          </div>
        </div>
      </div>
      
      <footer>
        <div class="grad-bottom"></div>
        <div class="footer">
          <div class="container">
            <span class="pull-right">
              <a href="#top">Back to top</a>
            </span>
            
            <span>Copyright © 2015-2017 Microsoft<br>Generated by <strong>DocFX</strong></span>
          </div>
        </div>
      </footer>
    </div>
    
    <script type="text/javascript" src="../../styles/docfx.vendor.js"></script>
    <script type="text/javascript" src="../../styles/docfx.js"></script>
    <script type="text/javascript" src="../../styles/main.js"></script>
  </body>
</html>
